@sentry/node 10.70.0 → 11.0.0-alpha.1

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

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

@@ -1,49 +0,0 @@
-export declare enum EndOperation {
-    AutoAck = "auto ack",
-    Ack = "ack",
-    AckAll = "ackAll",
-    Reject = "reject",
-    Nack = "nack",
-    NackAll = "nackAll",
-    ChannelClosed = "channel closed",
-    ChannelError = "channel error",
-    InstrumentationTimeout = "instrumentation timeout"
-}
-export interface Message {
-    content: Buffer;
-    fields: MessageFields;
-    properties: MessageProperties;
-}
-export interface ConsumeMessage extends Message {
-    fields: ConsumeMessageFields;
-}
-export interface CommonMessageFields {
-    deliveryTag: number;
-    redelivered: boolean;
-    exchange: string;
-    routingKey: string;
-}
-export interface MessageFields extends CommonMessageFields {
-    messageCount?: number;
-    consumerTag?: string;
-}
-export interface ConsumeMessageFields extends CommonMessageFields {
-    deliveryTag: number;
-}
-export interface MessageProperties {
-    contentType: any | undefined;
-    contentEncoding: any | undefined;
-    headers: any;
-    deliveryMode: any | undefined;
-    priority: any | undefined;
-    correlationId: any | undefined;
-    replyTo: any | undefined;
-    expiration: any | undefined;
-    messageId: any | undefined;
-    timestamp: any | undefined;
-    type: any | undefined;
-    userId: any | undefined;
-    appId: any | undefined;
-    clusterId: any | undefined;
-}
-//# sourceMappingURL=types.d.ts.map

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

@@ -1,42 +0,0 @@
-import { Span, SpanAttributes } from '@sentry/core';
-import { Channel, ConfirmChannel, Connection, Options } from './amqplib-types';
-import { ConsumeMessage, Message } from './types';
-export declare const MESSAGE_STORED_SPAN: unique symbol;
-export declare const CHANNEL_SPANS_NOT_ENDED: unique symbol;
-export declare const CHANNEL_CONSUME_TIMEOUT_TIMER: unique symbol;
-export declare const CONNECTION_ATTRIBUTES: unique symbol;
-export declare const CHANNEL_IS_CONFIRM_PUBLISHING: unique symbol;
-export type InstrumentationConnection = Connection & {
-    [CONNECTION_ATTRIBUTES]?: SpanAttributes;
-};
-export type InstrumentationPublishChannel = (Channel | ConfirmChannel) & {
-    connection: InstrumentationConnection;
-    [CHANNEL_IS_CONFIRM_PUBLISHING]?: boolean;
-};
-export type InstrumentationConsumeChannel = Channel & {
-    connection: InstrumentationConnection;
-    [CHANNEL_SPANS_NOT_ENDED]?: {
-        msg: ConsumeMessage;
-        timeOfConsume: number;
-    }[];
-    [CHANNEL_CONSUME_TIMEOUT_TIMER]?: NodeJS.Timeout;
-};
-export type InstrumentationMessage = Message & {
-    [MESSAGE_STORED_SPAN]?: Span;
-};
-export type InstrumentationConsumeMessage = ConsumeMessage & {
-    [MESSAGE_STORED_SPAN]?: Span;
-};
-export declare const normalizeExchange: (exchangeName: string) => string;
-export declare const getConnectionAttributesFromServer: (conn: Connection) => SpanAttributes;
-export declare const getConnectionAttributesFromUrl: (url: string | Options.Connect) => SpanAttributes;
-/** Reads a propagation header value off an amqplib message as a string. */
-export declare function getHeaderAsString(headers: Record<string, unknown> | undefined, key: string): string | undefined;
-/** Starts an inactive producer span and propagates its trace into the publish `options.headers`. */
-export declare function startPublishSpan(exchange: string, routingKey: string, channel: InstrumentationPublishChannel, options?: Options.Publish): {
-    span: Span;
-    modifiedOptions: Options.Publish;
-};
-/** Starts an inactive consumer (process) span carrying the amqplib messaging attributes. */
-export declare function startConsumeSpan(queue: string, msg: InstrumentationConsumeMessage, channel: InstrumentationConsumeChannel): Span;
-//# sourceMappingURL=utils.d.ts.map

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

@@ -1,62 +0,0 @@
-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: follows `dataCollection.genAI.inputs`, or the deprecated `sendDefaultPii` option)
- * - `recordOutputs`: Whether to record response text (default: follows `dataCollection.genAI.outputs`, or the deprecated `sendDefaultPii` option)
- *
- * ### Default Behavior
- *
- * By default, the integration will:
- * - Record inputs and outputs based on `dataCollection.genAI` in your Sentry client options
- *   (or the deprecated `sendDefaultPii` option, for backwards compatibility)
- * - Integration-level `recordInputs`/`recordOutputs` options take precedence over global config
- *
- * @example
- * ```javascript
- * // Always record inputs and outputs regardless of global dataCollection config
- * Sentry.init({
- *   integrations: [
- *     Sentry.anthropicAIIntegration({
- *       recordInputs: true,
- *       recordOutputs: true
- *     })
- *   ],
- * });
- *
- * // Never record inputs/outputs regardless of global dataCollection config
- * Sentry.init({
- *   dataCollection: { genAI: { inputs: true, outputs: true } },
- *   integrations: [
- *     Sentry.anthropicAIIntegration({
- *       recordInputs: false,
- *       recordOutputs: false
- *     })
- *   ],
- * });
- * ```
- *
- */
-export declare const anthropicAIIntegration: (options?: AnthropicAiOptions | undefined) => import("@sentry/core").Integration & {
-    name: "Anthropic_AI";
-};
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,19 +0,0 @@
-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/index.d.ts

@@ -1,48 +0,0 @@
-import { ConnectInstrumentation } from './vendored/instrumentation';
-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 & {
-    name: "Connect";
-};
-/**
- * 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=index.d.ts.map

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

@@ -1,9 +0,0 @@
-export declare enum AttributeNames {
-    CONNECT_TYPE = "connect.type",
-    CONNECT_NAME = "connect.name"
-}
-export declare enum ConnectTypes {
-    MIDDLEWARE = "middleware",
-    REQUEST_HANDLER = "request_handler"
-}
-//# sourceMappingURL=AttributeNames.d.ts.map

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

@@ -1,18 +0,0 @@
-import { HandleFunction, NextFunction, Server, Use } from './internal-types';
-import { Span } from '@sentry/core';
-import { InstrumentationConfig } from '@opentelemetry/instrumentation';
-import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-/** Connect instrumentation for OpenTelemetry */
-export declare class ConnectInstrumentation extends InstrumentationBase {
-    constructor(config?: InstrumentationConfig);
-    init(): InstrumentationNodeModuleDefinition[];
-    private _patchApp;
-    private _patchConstructor;
-    _patchNext(next: NextFunction, span: Span, finishSpan: () => void): NextFunction;
-    _startSpan(routeName: string, middleWare: HandleFunction): Span;
-    _patchMiddleware(routeName: string, middleWare: HandleFunction): HandleFunction;
-    _patchUse(original: Server['use']): Use;
-    _patchHandle(original: Server['handle']): Server['handle'];
-    _patchOut(out: NextFunction, completeStack: () => void): NextFunction;
-}
-//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -1,36 +0,0 @@
-import * as http from 'http';
-export type IncomingMessage = http.IncomingMessage & {
-    originalUrl?: http.IncomingMessage['url'] | undefined;
-};
-export type NextFunction = (err?: unknown) => void;
-export type SimpleHandleFunction = (req: IncomingMessage, res: http.ServerResponse) => void;
-export type NextHandleFunction = (req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
-export type ErrorHandleFunction = (err: unknown, req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
-export type HandleFunction = SimpleHandleFunction | NextHandleFunction | ErrorHandleFunction;
-export interface Server extends NodeJS.EventEmitter {
-    (req: http.IncomingMessage, res: http.ServerResponse, next?: Function): void;
-    route: string;
-    stack: Array<{
-        route: string;
-        handle: HandleFunction | http.Server;
-    }>;
-    use(fn: NextHandleFunction): Server;
-    use(fn: HandleFunction): Server;
-    use(route: string, fn: NextHandleFunction): Server;
-    use(route: string, fn: HandleFunction): Server;
-    handle(req: http.IncomingMessage, res: http.ServerResponse, next: Function): void;
-}
-export declare const _LAYERS_STORE_PROPERTY: unique symbol;
-export type UseArgs1 = [
-    HandleFunction
-];
-export type UseArgs2 = [
-    string,
-    HandleFunction
-];
-export type UseArgs = UseArgs1 | UseArgs2;
-export type Use = (...args: UseArgs) => Server;
-export type PatchedRequest = {
-    [_LAYERS_STORE_PROPERTY]: string[];
-} & IncomingMessage;
-//# sourceMappingURL=internal-types.d.ts.map

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

@@ -1,5 +0,0 @@
-import { PatchedRequest } from './internal-types';
-export declare const addNewStackLayer: (request: PatchedRequest) => () => void;
-export declare const replaceCurrentStackRoute: (request: PatchedRequest, newRoute?: string) => void;
-export declare const generateRoute: (request: PatchedRequest) => string;
-//# sourceMappingURL=utils.d.ts.map

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

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

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

@@ -1,18 +0,0 @@
-import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-export declare class DataloaderInstrumentation extends InstrumentationBase {
-    constructor(config?: {});
-    protected init(): InstrumentationNodeModuleDefinition[];
-    private _wrapBatchLoadFn;
-    private _getPatchedConstructor;
-    private _patchLoad;
-    private _getPatchedLoad;
-    private _patchLoadMany;
-    private _getPatchedLoadMany;
-    private _patchPrime;
-    private _getPatchedPrime;
-    private _patchClear;
-    private _getPatchedClear;
-    private _patchClearAll;
-    private _getPatchedClearAll;
-}
-//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -1,22 +0,0 @@
-import { SpanLink } from '@sentry/core';
-export type BatchLoadFn<K, V> = (keys: ReadonlyArray<K>) => PromiseLike<ArrayLike<V | Error>>;
-/** A `DataLoader` instance. */
-export interface DataLoader<K = unknown, V = unknown> {
-    _batchLoadFn: BatchLoadFn<K, V>;
-    _batch: {
-        spanLinks?: SpanLink[];
-    } | null;
-    load(key: K): Promise<V>;
-    loadMany(keys: ArrayLike<K>): Promise<Array<V | Error>>;
-    prime(key: K, value: V | Error): this;
-    clear(key: K): this;
-    clearAll(): this;
-    name: string | undefined;
-    [key: string]: any;
-}
-/** The `DataLoader` class/constructor. */
-export interface DataLoaderConstructor {
-    new <K, V>(batchLoadFn: BatchLoadFn<K, V>, options?: any): DataLoader<K, V>;
-    prototype: DataLoader<unknown, unknown>;
-}
-//# sourceMappingURL=types.d.ts.map

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

@@ -1,19 +0,0 @@
-import { InstrumentationConfig } from '@opentelemetry/instrumentation';
-import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { ExpressIntegrationOptions, ExpressHandlerOptions } from '@sentry/core';
-export { expressErrorHandler } from '@sentry/core';
-export declare function setupExpressErrorHandler(app: {
-    use: (middleware: any) => unknown;
-}, options?: ExpressHandlerOptions): void;
-export type ExpressInstrumentationConfig = InstrumentationConfig & Pick<ExpressIntegrationOptions, Exclude<keyof ExpressIntegrationOptions, 'express' | 'onRouteResolved'>>;
-export declare const instrumentExpress: ((options?: ExpressInstrumentationConfig | undefined) => ExpressInstrumentation) & {
-    id: string;
-};
-export declare class ExpressInstrumentation extends InstrumentationBase<ExpressInstrumentationConfig> {
-    constructor(config?: ExpressInstrumentationConfig);
-    init(): InstrumentationNodeModuleDefinition;
-}
-export declare const expressIntegration: (options?: ExpressInstrumentationConfig | undefined) => import("@sentry/core").Integration & {
-    name: "Express";
-};
-//# sourceMappingURL=express.d.ts.map