@depup/sentry__node 10.75.2-depup.0 → 11.1.0-depup.0

package/build/types/sdk/diagnosticsChannelInjection.d.ts

@@ -1,41 +0,0 @@
-import type { 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/sdk/diagnosticsChannelInjection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"diagnosticsChannelInjection.d.ts","sourceRoot":"","sources":["../../../src/sdk/diagnosticsChannelInjection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,2BAA2B;IAC1C,gFAAgF;IAChF,YAAY,EAAE,WAAW,EAAE,GAAG,SAAS,WAAW,EAAE,CAAC;IACrD,6EAA6E;IAC7E,4BAA4B,EAAE,MAAM,EAAE,CAAC;IACvC,sEAAsE;IACtE,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,qEAAqE;IACrE,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAKD;;;;;;GAMG;AACH,wBAAgB,oCAAoC,CAAC,IAAI,EAAE,MAAM,2BAA2B,GAAG,IAAI,CAElG;AAED,yEAAyE;AACzE,wBAAgB,oCAAoC,IAAI,OAAO,CAE9D;AAED;;;;;GAKG;AACH,wBAAgB,kCAAkC,IAAI,2BAA2B,GAAG,SAAS,CAK5F"}

package/build/types/sdk/experimentalUseDiagnosticsChannelInjection.d.ts

@@ -1,37 +0,0 @@
-import { channelIntegrations } from '@sentry/server-utils/orchestrion';
-import type { 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/sdk/experimentalUseDiagnosticsChannelInjection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"experimentalUseDiagnosticsChannelInjection.d.ts","sourceRoot":"","sources":["../../../src/sdk/experimentalUseDiagnosticsChannelInjection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EAIpB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,0CAA0C,EAAE,MAAM,2CAA2C,CAAC;AAM5G,wBAAgB,uCAAuC,IAAI,OAAO,mBAAmB,CAEpF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,0CAA0C,CAExD,QAAQ,CAAC,EAAE,0CAA0C,GACpD,IAAI,CAwBN"}

package/build/types/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/utils/redisCache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"redisCache.d.ts","sourceRoot":"","sources":["../../../src/utils/redisCache.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,EAAE,CAAC,CAAC;AAI7E,eAAO,MAAM,YAAY,UAAkB,CAAC;AAC5C,eAAO,MAAM,YAAY,UAAmB,CAAC;AAC7C,eAAO,MAAM,eAAe,UAAoB,CAAC;AAGjD;6FAC6F;AAC7F,wBAAgB,YAAY,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAE9E;AAED,yDAAyD;AACzD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,GAAG,cAAc,GAAG,SAAS,CAUzG;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/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

package/build/types/utils/setHttpServerSpanRouteAttribute.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setHttpServerSpanRouteAttribute.d.ts","sourceRoot":"","sources":["../../../src/utils/setHttpServerSpanRouteAttribute.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAanE"}

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

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

@@ -1,44 +0,0 @@
-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 '@sentry/server-utils';
-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, applyDiagnosticsChannelInjectionIntegrations, } from './sdk';
-export { experimentalUseDiagnosticsChannelInjection, diagnosticsChannelInjectionIntegrations, } from './sdk/experimentalUseDiagnosticsChannelInjection';
-export { isDiagnosticsChannelInjectionEnabled } from './sdk/diagnosticsChannelInjection';
-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, setAttribute, setAttributes, 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, bindScopeToEmitter, suppressTracing, getActiveSpan, withActiveSpan, getRootSpan, spanToJSON, spanToTraceHeader, spanToBaggageHeader, trpcMiddleware, updateSpanName, supabaseIntegration, instrumentSupabaseClient, instrumentOpenAiClient, instrumentAnthropicAiClient, instrumentGoogleGenAIClient, zodErrorsIntegration, profiler, consoleLoggingIntegration, createConsolaReporter, wrapMcpServerWithSentry, featureFlagsIntegration, spanStreamingIntegration, createLangChainCallbackHandler, instrumentLangChainEmbeddings, instrumentStateGraph, 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, nodeRuntimeMetricsIntegration, NodeRuntimeMetricsOptions, consoleIntegration, pinoIntegration, createSentryWinstonTransport, SentryContextManager, systemErrorIntegration, generateInstrumentOnce, getSentryRelease, defaultStackParser, createGetModuleFromFilename, makeNodeTransport, NodeClient, cron, NODE_VERSION, validateOpenTelemetrySetup, withStreamedSpan, _INTERNAL_normalizeCollectionInterval } from '@sentry/node-core';
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,6 +0,0 @@
-/**
- * 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

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

@@ -1,12 +0,0 @@
-/**
- * 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 & {
-    name: "LaunchDarkly";
-};
-/**
- * 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

@@ -1,25 +0,0 @@
-/**
- * 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 & {
-    name: "OpenFeature";
-};
-/**
- * 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

@@ -1,8 +0,0 @@
-/**
- * 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 & {
-    name: "Statsig";
-};
-//# sourceMappingURL=statsig.d.ts.map

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

@@ -1,8 +0,0 @@
-/**
- * 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 & {
-    name: "Unleash";
-};
-//# sourceMappingURL=unleash.d.ts.map

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

@@ -1,14 +0,0 @@
-import { FsInstrumentationConfig } from './vendored/types';
-/**
- * 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?: FsInstrumentationConfig | undefined) => import("@sentry/core").Integration & {
-    name: "FileSystem";
-};
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,5 +0,0 @@
-import { FMember, FPMember } from './types';
-export declare const PROMISE_FUNCTIONS: FPMember[];
-export declare const CALLBACK_FUNCTIONS: FMember[];
-export declare const SYNC_FUNCTIONS: FMember[];
-//# sourceMappingURL=constants.d.ts.map

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

@@ -1,3 +0,0 @@
-import { FsInstrumentationConfig } from './types';
-export declare function enableFsInstrumentation(config?: FsInstrumentationConfig): void;
-//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -1,23 +0,0 @@
-import * as fs from 'fs';
-export type GenericFunction = (...args: any[]) => unknown;
-export type FunctionPropertyNames<T> = Exclude<{
-    [K in keyof T]: T[K] extends Function ? K : never;
-}[keyof T], undefined>;
-export type FunctionPropertyNamesTwoLevels<T> = Exclude<{
-    [K in keyof T]: {
-        [L in keyof T[K]]: L extends string ? T[K][L] extends Function ? K extends string ? L extends string ? string : never : never : never : never;
-    }[keyof T[K]];
-}[keyof T], undefined>;
-export type FMember = FunctionPropertyNames<typeof fs> | FunctionPropertyNamesTwoLevels<typeof fs>;
-export type FPMember = FunctionPropertyNames<(typeof fs)['promises']> | FunctionPropertyNamesTwoLevels<(typeof fs)['promises']>;
-export interface FsInstrumentationConfig {
-    /**
-     * Setting this option to `true` will include any filepath arguments from your `fs` API calls as span attributes.
-     */
-    recordFilePaths?: boolean;
-    /**
-     * Setting this option to `true` will include the error messages of failed `fs` API calls as a span attribute.
-     */
-    recordErrorMessagesAsSpanAttributes?: boolean;
-}
-//# sourceMappingURL=types.d.ts.map

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

@@ -1,15 +0,0 @@
-import * as fs from 'fs';
-import { FMember, FunctionPropertyNames, GenericFunction } from './types';
-type FS = typeof fs;
-export declare function splitTwoLevels<FSObject>(functionName: FMember): [
-    FunctionPropertyNames<FSObject> & string
-] | [
-    FunctionPropertyNames<FSObject> & string,
-    string
-];
-export declare function indexFs<FSObject extends FS | FS['promises']>(fs: FSObject, member: FMember): {
-    objectToPatch: Record<string, GenericFunction>;
-    functionNameToPatch: string;
-};
-export {};
-//# sourceMappingURL=utils.d.ts.map

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

@@ -1,134 +0,0 @@
-import { RequestOptions } from 'node:http';
-import { HttpClientRequest, HttpIncomingMessage, HttpServerResponse, Span } from '@sentry/core';
-import { instrumentHttpOutgoingRequests } from '@sentry/node-core';
-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: HttpIncomingMessage) => 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: HttpIncomingMessage, response: HttpServerResponse) => 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: HttpIncomingMessage | HttpClientRequest) => void;
-        responseHook?: (span: Span, response: HttpIncomingMessage | HttpServerResponse) => void;
-        applyCustomAttributesOnSpan?: (span: Span, request: HttpIncomingMessage | HttpClientRequest, response: HttpIncomingMessage | HttpServerResponse) => void;
-    };
-}
-export declare const instrumentSentryHttp: typeof instrumentHttpOutgoingRequests & {
-    id: string;
-};
-/**
- * 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 & {
-    name: "Http";
-};
-export {};
-//# sourceMappingURL=http.d.ts.map

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

@@ -1,9 +0,0 @@
-import { NodeFetchOptions } from '@sentry/node-core';
-/**
- * Instrument outgoing fetch requests made through the native node `fetch` API.
- * This emits (depending on the integration options) spans and breadcrumbs, as well as injecting trace propagation headers into the request.
- */
-export declare const nativeNodeFetchIntegration: (options?: NodeFetchOptions | undefined) => import("@sentry/core").Integration & {
-    name: "NodeFetch";
-};
-//# sourceMappingURL=node-fetch.d.ts.map

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

@@ -1,9 +0,0 @@
-import { InstrumentationModuleFile } from '@opentelemetry/instrumentation';
-export declare class InstrumentationNodeModuleFile implements InstrumentationModuleFile {
-    name: string;
-    supportedVersions: string[];
-    patch: (moduleExports: any, moduleVersion?: string) => any;
-    unpatch: (moduleExports?: any, moduleVersion?: string) => void;
-    constructor(name: string, supportedVersions: string[], patch: (moduleExports: any, moduleVersion?: string) => any, unpatch: (moduleExports?: any, moduleVersion?: string) => void);
-}
-//# sourceMappingURL=InstrumentationNodeModuleFile.d.ts.map

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

@@ -1,22 +0,0 @@
-import { AmqplibInstrumentation } from './vendored/instrumentation';
-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 & {
-    name: "Amqplib";
-};
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,44 +0,0 @@
-export interface Connection {
-    connection: {
-        serverProperties: {
-            product?: string;
-            [key: string]: any;
-        };
-    };
-    [key: string]: any;
-}
-export interface Channel {
-    connection: Connection;
-    [key: string]: any;
-}
-export interface ConfirmChannel extends Channel {
-}
-export declare namespace Options {
-    interface Connect {
-        protocol?: string;
-        hostname?: string;
-        port?: number;
-        username?: string;
-        vhost?: string;
-    }
-    interface Consume {
-        consumerTag?: string;
-        noLocal?: boolean;
-        noAck?: boolean;
-        exclusive?: boolean;
-        priority?: number;
-        arguments?: any;
-    }
-    interface Publish {
-        headers?: any;
-        [key: string]: any;
-    }
-}
-export declare namespace Replies {
-    interface Empty {
-    }
-    interface Consume {
-        consumerTag: string;
-    }
-}
-//# sourceMappingURL=amqplib-types.d.ts.map

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

@@ -1,11 +0,0 @@
-import { InstrumentationConfig } from '@opentelemetry/instrumentation';
-import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-export declare class AmqplibInstrumentation extends InstrumentationBase<InstrumentationConfig> {
-    constructor(config?: InstrumentationConfig);
-    protected init(): InstrumentationNodeModuleDefinition;
-    private patchConnect;
-    private unpatchConnect;
-    private patchChannelModel;
-    private unpatchChannelModel;
-}
-//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -1,11 +0,0 @@
-import { Connection, Options, Replies } from './amqplib-types';
-import { EndOperation, ConsumeMessage, Message } from './types';
-import { InstrumentationConsumeChannel, InstrumentationPublishChannel } from './utils';
-export declare function getConnectPatch(original: (url: string | Options.Connect, socketOptions: any, openCallback: (err: any, connection: Connection) => void) => Connection): (this: unknown, url: string | Options.Connect, socketOptions: any, openCallback: Function) => Connection;
-export declare function getChannelEmitPatch(original: Function): (this: InstrumentationConsumeChannel, eventName: string) => void;
-export declare function getAckAllPatch(isRejected: boolean, endOperation: EndOperation): (original: Function) => (this: InstrumentationConsumeChannel, requeueOrEmpty?: boolean) => void;
-export declare function getAckPatch(isRejected: boolean, endOperation: EndOperation): (original: Function) => (this: InstrumentationConsumeChannel, message: Message, allUpToOrRequeue?: boolean, requeue?: boolean) => void;
-export declare function getConsumePatch(original: Function): (this: InstrumentationConsumeChannel, queue: string, onMessage: (msg: ConsumeMessage | null) => void, options?: Options.Consume) => Promise<Replies.Consume>;
-export declare function getConfirmedPublishPatch(original: Function): (this: InstrumentationPublishChannel, exchange: string, routingKey: string, content: Buffer, options?: Options.Publish, callback?: (err: any, ok: Replies.Empty) => void) => boolean;
-export declare function getPublishPatch(original: Function): (this: InstrumentationPublishChannel, exchange: string, routingKey: string, content: Buffer, options?: Options.Publish) => boolean;
-//# sourceMappingURL=patches.d.ts.map

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

@@ -1,23 +0,0 @@
-/** A string identifying the kind of message consumption. */
-export declare const ATTR_MESSAGING_OPERATION: "messaging.operation";
-/** The message destination name (the exchange for amqplib). */
-export declare const ATTR_MESSAGING_DESTINATION: "messaging.destination";
-/** The kind of message destination. */
-export declare const ATTR_MESSAGING_DESTINATION_KIND: "messaging.destination_kind";
-/** RabbitMQ message routing key. */
-export declare const ATTR_MESSAGING_RABBITMQ_ROUTING_KEY: "messaging.rabbitmq.routing_key";
-/** The name of the transport protocol. */
-export declare const ATTR_MESSAGING_PROTOCOL: "messaging.protocol";
-/** The version of the transport protocol. */
-export declare const ATTR_MESSAGING_PROTOCOL_VERSION: "messaging.protocol_version";
-/** Connection string. */
-export declare const ATTR_MESSAGING_URL: "messaging.url";
-/** A value used by the messaging system as an identifier for the message, represented as a string. */
-export declare const OLD_ATTR_MESSAGING_MESSAGE_ID: "messaging.message_id";
-/** The conversation ID (a.k.a. correlation ID) identifying the conversation the message belongs to. */
-export declare const ATTR_MESSAGING_CONVERSATION_ID: "messaging.conversation_id";
-/** Value for `messaging.destination_kind` when the destination is a topic. */
-export declare const MESSAGING_DESTINATION_KIND_VALUE_TOPIC: "topic";
-/** Value for `messaging.operation` when the message is being processed by a consumer. */
-export declare const MESSAGING_OPERATION_VALUE_PROCESS: "process";
-//# sourceMappingURL=semconv.d.ts.map