@depup/sentry__node 10.48.0-depup.0 → 10.67.0-depup.1

package/build/types-ts3.8/integrations/tracing/{connect.d.ts → connect/index.d.ts}

@@ -1,4 +1,4 @@
-import { ConnectInstrumentation } from '@opentelemetry/instrumentation-connect';
+import { ConnectInstrumentation } from './vendored/instrumentation';
 type ConnectApp = {
     use: (middleware: any) => void;
 };
@@ -21,7 +21,9 @@ export declare const instrumentConnect: ((options?: unknown) => ConnectInstrumen
  * })
  * ```
  */
-export declare const connectIntegration: () => import("@sentry/core").Integration;
+export declare const connectIntegration: () => import("@sentry/core").Integration & {
+    name: "Connect";
+};
 /**
  * Add a Connect middleware to capture errors to Sentry.
  *
@@ -43,4 +45,4 @@ export declare const connectIntegration: () => import("@sentry/core").Integratio
  */
 export declare const setupConnectErrorHandler: (app: ConnectApp) => void;
 export {};
-//# sourceMappingURL=connect.d.ts.map
+//# sourceMappingURL=index.d.ts.map

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

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

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

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

@@ -0,0 +1,5 @@
+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.d.ts → dataloader/index.d.ts}

@@ -1,4 +1,4 @@
-import { DataloaderInstrumentation } from '@opentelemetry/instrumentation-dataloader';
+import { DataloaderInstrumentation } from './vendored/instrumentation';
 export declare const instrumentDataloader: ((options?: unknown) => DataloaderInstrumentation) & {
     id: string;
 };
@@ -16,5 +16,7 @@ export declare const instrumentDataloader: ((options?: unknown) => DataloaderIns
  * });
  * ```
  */
-export declare const dataloaderIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=dataloader.d.ts.map
+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

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

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

@@ -13,5 +13,7 @@ export declare class ExpressInstrumentation extends InstrumentationBase<ExpressI
     constructor(config?: ExpressInstrumentationConfig);
     init(): InstrumentationNodeModuleDefinition;
 }
-export declare const expressIntegration: (options?: ExpressInstrumentationConfig | undefined) => import("@sentry/core").Integration;
+export declare const expressIntegration: (options?: ExpressInstrumentationConfig | undefined) => import("@sentry/core").Integration & {
+    name: "Express";
+};
 //# sourceMappingURL=express.d.ts.map

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

@@ -1,6 +1,8 @@
-import { Instrumentation, InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { Integration } from '@sentry/core';
 import { FastifyMinimal, FastifyReply, FastifyRequest } from './types';
 import { FastifyInstrumentationV3 } from './v3/instrumentation';
+import { instrumentFastify } from '@sentry/server-utils';
+export { instrumentFastify };
 /**
  * Options for the Fastify integration.
  *
@@ -74,9 +76,6 @@ interface FastifyHandlerOptions {
 export declare const instrumentFastifyV3: ((options?: unknown) => FastifyInstrumentationV3) & {
     id: string;
 };
-export declare const instrumentFastify: ((options?: unknown) => Instrumentation<InstrumentationConfig>) & {
-    id: string;
-};
 /**
  * Adds Sentry tracing instrumentation for [Fastify](https://fastify.dev/).
  *
@@ -93,7 +92,9 @@ export declare const instrumentFastify: ((options?: unknown) => Instrumentation<
  * })
  * ```
  */
-export declare const fastifyIntegration: (options?: Partial<FastifyIntegrationOptions> | undefined) => import("@sentry/core").Integration;
+export declare const fastifyIntegration: (options?: Partial<FastifyIntegrationOptions> | undefined) => Integration & {
+    name: string;
+};
 /**
  * Add an Fastify error handler to capture errors to Sentry.
  *
@@ -115,5 +116,4 @@ export declare const fastifyIntegration: (options?: Partial<FastifyIntegrationOp
  * ```
  */
 export declare function setupFastifyErrorHandler(fastify: FastifyMinimal, options?: Partial<FastifyHandlerOptions>): void;
-export {};
 //# sourceMappingURL=index.d.ts.map

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

@@ -2,5 +2,7 @@ import { FirebaseInstrumentation } from './otel';
 export declare const instrumentFirebase: ((options?: unknown) => FirebaseInstrumentation) & {
     id: string;
 };
-export declare const firebaseIntegration: () => import("@sentry/core").Integration;
+export declare const firebaseIntegration: () => import("@sentry/core").Integration & {
+    name: "Firebase";
+};
 //# sourceMappingURL=firebase.d.ts.map

package/build/types-ts3.8/integrations/tracing/firebase/otel/firebaseInstrumentation.d.ts

@@ -1,15 +1,10 @@
-import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { FirebaseInstrumentationConfig } from './types';
+import { InstrumentationConfig, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { InstrumentationBase } from '@opentelemetry/instrumentation';
 /**
  * Instrumentation for Firebase services, specifically Firestore.
  */
-export declare class FirebaseInstrumentation extends InstrumentationBase<FirebaseInstrumentationConfig> {
-    constructor(config?: FirebaseInstrumentationConfig);
-    /**
-     * sets config
-     * @param config
-     */
-    setConfig(config?: FirebaseInstrumentationConfig): void;
+export declare class FirebaseInstrumentation extends InstrumentationBase<InstrumentationConfig> {
+    constructor(config?: InstrumentationConfig);
     /**
      *
      * @protected

package/build/types-ts3.8/integrations/tracing/firebase/otel/patches/firestore.d.ts

@@ -1,20 +1,17 @@
-import { Tracer } from '@opentelemetry/api';
 import { InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { FirebaseInstrumentationConfig, FirestoreSettings } from '../types';
+import { FirestoreSettings } from '../types';
 type ShimmerWrap = (target: any, name: string, wrapper: (...args: any[]) => any) => void;
 type ShimmerUnwrap = (target: any, name: string) => void;
 /**
  *
- * @param tracer - Opentelemetry Tracer
  * @param firestoreSupportedVersions - supported version of firebase/firestore
  * @param wrap - reference to native instrumentation wrap function
  * @param unwrap - reference to native instrumentation wrap function
  */
-export declare function patchFirestore(tracer: Tracer, firestoreSupportedVersions: string[], wrap: ShimmerWrap, unwrap: ShimmerUnwrap, config: FirebaseInstrumentationConfig): InstrumentationNodeModuleDefinition;
+export declare function patchFirestore(firestoreSupportedVersions: string[], wrap: ShimmerWrap, unwrap: ShimmerUnwrap): InstrumentationNodeModuleDefinition;
 /**
  * Gets the server address and port attributes from the Firestore settings.
  * It's best effort to extract the address and port from the settings, especially for IPv6.
- * @param span - The span to set attributes on.
  * @param settings - The Firestore settings containing host information.
  */
 export declare function getPortAndAddress(settings: FirestoreSettings): {

package/build/types-ts3.8/integrations/tracing/firebase/otel/patches/functions.d.ts

@@ -1,23 +1,18 @@
-import { Tracer } from '@opentelemetry/api';
 import { InstrumentationBase } from '@opentelemetry/instrumentation';
 import { InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { FirebaseFunctions, FirebaseInstrumentationConfig, OverloadedParameters } from '../types';
+import { FirebaseFunctions, OverloadedParameters } from '../types';
 /**
  * Patches Firebase Functions v2 to add OpenTelemetry instrumentation
- * @param tracer - Opentelemetry Tracer
  * @param functionsSupportedVersions - supported versions of firebase-functions
  * @param wrap - reference to native instrumentation wrap function
  * @param unwrap - reference to native instrumentation unwrap function
- * @param config - Firebase instrumentation config
  */
-export declare function patchFunctions(tracer: Tracer, functionsSupportedVersions: string[], wrap: InstrumentationBase['_wrap'], unwrap: InstrumentationBase['_unwrap'], config: FirebaseInstrumentationConfig): InstrumentationNodeModuleDefinition;
+export declare function patchFunctions(functionsSupportedVersions: string[], wrap: InstrumentationBase['_wrap'], unwrap: InstrumentationBase['_unwrap']): InstrumentationNodeModuleDefinition;
 /**
  * Patches Cloud Functions for Firebase (v2) to add OpenTelemetry instrumentation
  *
- * @param tracer - Opentelemetry Tracer
- * @param functionsConfig - Firebase instrumentation config
  * @param triggerType - Type of trigger
  * @returns A function that patches the function
  */
-export declare function patchV2Functions<T extends FirebaseFunctions = FirebaseFunctions>(tracer: Tracer, functionsConfig: FirebaseInstrumentationConfig['functions'], triggerType: string): (original: T) => (...args: OverloadedParameters<T>) => ReturnType<T>;
+export declare function patchV2Functions<T extends FirebaseFunctions = FirebaseFunctions>(triggerType: string): (original: T) => (...args: OverloadedParameters<T>) => ReturnType<T>;
 //# sourceMappingURL=functions.d.ts.map

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

@@ -1,5 +1,3 @@
-import { Span } from '@opentelemetry/api';
-import { InstrumentationConfig } from '@opentelemetry/instrumentation';
 export interface FirebaseOptions {
     [key: string]: any;
     apiKey?: string;
@@ -70,24 +68,6 @@ export interface FirestoreSettings {
     experimentalAutoDetectLongPolling?: boolean;
     useFetchStreams?: boolean;
 }
-/**
- * Firebase Auto Instrumentation
- */
-export interface FirebaseInstrumentationConfig extends InstrumentationConfig {
-    firestoreSpanCreationHook?: FirestoreSpanCreationHook;
-    functions?: FunctionsConfig;
-}
-export interface FunctionsConfig {
-    requestHook?: RequestHook;
-    responseHook?: ResponseHook;
-    errorHook?: ErrorHook;
-}
-export type RequestHook = (span: Span) => void;
-export type ResponseHook = (span: Span, error?: unknown) => void;
-export type ErrorHook = (span: Span, error?: unknown) => Promise<void> | void;
-export interface FirestoreSpanCreationHook {
-    (span: Span): void;
-}
 export type GetDocsType<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> = (query: CollectionReference<AppModelType, DbModelType>) => Promise<QuerySnapshot<AppModelType, DbModelType>>;
 export type SetDocType<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> = ((reference: DocumentReference<AppModelType, DbModelType>, data: WithFieldValue<AppModelType>) => Promise<void>) & ((reference: DocumentReference<AppModelType, DbModelType>, data: PartialWithFieldValue<AppModelType>, options: SetOptions) => Promise<void>);
 export type AddDocType<AppModelType, DbModelType extends DocumentData> = (reference: CollectionReference<AppModelType, DbModelType>, data: WithFieldValue<AppModelType>) => Promise<DocumentReference<AppModelType, DbModelType>>;

package/build/types-ts3.8/integrations/tracing/{genericPool.d.ts → genericPool/index.d.ts}

@@ -1,4 +1,4 @@
-import { GenericPoolInstrumentation } from '@opentelemetry/instrumentation-generic-pool';
+import { GenericPoolInstrumentation } from './vendored/instrumentation';
 export declare const instrumentGenericPool: ((options?: unknown) => GenericPoolInstrumentation) & {
     id: string;
 };
@@ -16,5 +16,7 @@ export declare const instrumentGenericPool: ((options?: unknown) => GenericPoolI
  * });
  * ```
  */
-export declare const genericPoolIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=genericPool.d.ts.map
+export declare const genericPoolIntegration: () => import("@sentry/core").Integration & {
+    name: "GenericPool";
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/genericPool/vendored/generic-pool-types.d.ts

@@ -0,0 +1,5 @@
+export declare class Pool<T> {
+    acquire(priority?: number): PromiseLike<T>;
+    [key: string]: unknown;
+}
+//# sourceMappingURL=generic-pool-types.d.ts.map

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

@@ -0,0 +1,11 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+export declare class GenericPoolInstrumentation extends InstrumentationBase {
+    private _isDisabled;
+    constructor(config?: InstrumentationConfig);
+    init(): InstrumentationNodeModuleDefinition[];
+    private _acquirePatcher;
+    private _poolWrapper;
+    private _acquireWithCallbacksPatcher;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -21,18 +21,19 @@ export declare const instrumentGoogleGenAI: ((options?: GoogleGenAIOptions | und
  *
  * ## Options
  *
- * - `recordInputs`: Whether to record prompt messages (default: respects `sendDefaultPii` client option)
- * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client option)
+ * - `recordInputs`: Whether to record prompt messages (default: follows `dataCollection.genAI.inputs`)
+ * - `recordOutputs`: Whether to record response text (default: follows `dataCollection.genAI.outputs`)
  *
  * ### 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
+ * - 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
- * // Record inputs and outputs when sendDefaultPii is false
+ * // Always record inputs and outputs regardless of global dataCollection config
  * Sentry.init({
  *   integrations: [
  *     Sentry.googleGenAiIntegration({
@@ -42,9 +43,9 @@ export declare const instrumentGoogleGenAI: ((options?: GoogleGenAIOptions | und
  *   ],
  * });
  *
- * // Never record inputs/outputs regardless of sendDefaultPii
+ * // Never record inputs/outputs regardless of global dataCollection config
  * Sentry.init({
- *   sendDefaultPii: true,
+ *   dataCollection: { genAI: { inputs: true, outputs: true } },
  *   integrations: [
  *     Sentry.googleGenAiIntegration({
  *       recordInputs: false,
@@ -55,5 +56,7 @@ export declare const instrumentGoogleGenAI: ((options?: GoogleGenAIOptions | und
  * ```
  *
  */
-export declare const googleGenAIIntegration: (options?: GoogleGenAIOptions | undefined) => import("@sentry/core").Integration;
+export declare const googleGenAIIntegration: (options?: GoogleGenAIOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Google_GenAI";
+};
 //# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/{graphql.d.ts → graphql/index.d.ts}

@@ -1,4 +1,4 @@
-import { GraphQLInstrumentation } from '@opentelemetry/instrumentation-graphql';
+import { GraphQLInstrumentation } from './vendored/instrumentation';
 interface GraphqlOptions {
     /**
      * Do not create spans for resolvers.
@@ -43,6 +43,8 @@ export declare const instrumentGraphql: ((options: GraphqlOptions) => GraphQLIns
  *  integrations: [Sentry.graphqlIntegration()],
  * });
  */
-export declare const graphqlIntegration: (options?: GraphqlOptions | undefined) => import("@sentry/core").Integration;
+export declare const graphqlIntegration: (options?: GraphqlOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Graphql";
+};
 export {};
-//# sourceMappingURL=graphql.d.ts.map
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,38 @@
+export declare enum AllowedOperationTypes {
+    QUERY = "query",
+    MUTATION = "mutation",
+    SUBSCRIPTION = "subscription"
+}
+export declare enum TokenKind {
+    SOF = "<SOF>",
+    EOF = "<EOF>",
+    BANG = "!",
+    DOLLAR = "$",
+    AMP = "&",
+    PAREN_L = "(",
+    PAREN_R = ")",
+    SPREAD = "...",
+    COLON = ":",
+    EQUALS = "=",
+    AT = "@",
+    BRACKET_L = "[",
+    BRACKET_R = "]",
+    BRACE_L = "{",
+    PIPE = "|",
+    BRACE_R = "}",
+    NAME = "Name",
+    INT = "Int",
+    FLOAT = "Float",
+    STRING = "String",
+    BLOCK_STRING = "BlockString",
+    COMMENT = "Comment"
+}
+export declare enum SpanNames {
+    EXECUTE = "graphql.execute",
+    PARSE = "graphql.parse",
+    RESOLVE = "graphql.resolve",
+    VALIDATE = "graphql.validate",
+    SCHEMA_VALIDATE = "graphql.validateSchema",
+    SCHEMA_PARSE = "graphql.parseSchema"
+}
+//# sourceMappingURL=enum.d.ts.map

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

@@ -0,0 +1,10 @@
+export declare enum AttributeNames {
+    SOURCE = "graphql.source",
+    FIELD_NAME = "graphql.field.name",
+    FIELD_PATH = "graphql.field.path",
+    FIELD_TYPE = "graphql.field.type",
+    PARENT_NAME = "graphql.parent.name",
+    OPERATION_TYPE = "graphql.operation.type",
+    OPERATION_NAME = "graphql.operation.name"
+}
+//# sourceMappingURL=AttributeNames.d.ts.map

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

@@ -0,0 +1,2 @@
+export { DefinitionNode, DocumentNode, ExecutionArgs, ExecutionResult, GraphQLError, GraphQLFieldResolver, GraphQLObjectType, GraphQLOutputType, GraphQLResolveInfo, GraphQLSchema, GraphQLType, GraphQLTypeResolver, GraphQLUnionType, Location, Maybe, OperationDefinitionNode, ParseOptions, PromiseOrValue, Source, Token, TypeInfo, ValidationRule, } from '@sentry/server-utils/orchestrion';
+//# sourceMappingURL=graphql-types.d.ts.map

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

@@ -0,0 +1,25 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { GraphQLInstrumentationConfig, GraphQLInstrumentationParsedConfig } from './types';
+export declare class GraphQLInstrumentation extends InstrumentationBase<GraphQLInstrumentationParsedConfig> {
+    constructor(config?: GraphQLInstrumentationConfig);
+    setConfig(config?: GraphQLInstrumentationConfig): void;
+    protected init(): InstrumentationNodeModuleDefinition;
+    private _addPatchingExecute;
+    private _addPatchingParser;
+    private _addPatchingValidate;
+    private _patchExecute;
+    private _handleExecutionResult;
+    /**
+     * Applies Sentry-specific span mutations based on the GraphQL execution result:
+     * - Marks the execute span as errored if the result contains errors (and no status was set yet)
+     * - Optionally renames the containing root span to include the GraphQL operation name(s)
+     */
+    private _updateSpanFromResult;
+    private _patchParse;
+    private _patchValidate;
+    private _parse;
+    private _validate;
+    private _createExecuteSpan;
+    private _wrapExecuteArgs;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1,63 @@
+import { Span } from '@sentry/core';
+import { DocumentNode, ExecutionArgs, ExecutionResult, GraphQLError, GraphQLFieldResolver, GraphQLSchema, GraphQLTypeResolver, Maybe, ParseOptions, PromiseOrValue, Source, TypeInfo, ValidationRule } from './graphql-types';
+import { OTEL_GRAPHQL_DATA_SYMBOL, OTEL_PATCHED_SYMBOL } from './symbols';
+export { Maybe } from './graphql-types';
+export declare const OPERATION_NOT_SUPPORTED: string;
+export type executeFunctionWithObj = (args: ExecutionArgs) => PromiseOrValue<ExecutionResult>;
+export type executeArgumentsArray = [
+    GraphQLSchema,
+    DocumentNode,
+    any,
+    any,
+    Maybe<{
+        [key: string]: any;
+    }>,
+    Maybe<string>,
+    Maybe<GraphQLFieldResolver<any, any>>,
+    Maybe<GraphQLTypeResolver<any, any>>
+];
+export type executeFunctionWithArgs = (schema: GraphQLSchema, document: DocumentNode, rootValue?: any, contextValue?: any, variableValues?: Maybe<{
+    [key: string]: any;
+}>, operationName?: Maybe<string>, fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>, typeResolver?: Maybe<GraphQLTypeResolver<any, any>>) => PromiseOrValue<ExecutionResult>;
+export interface OtelExecutionArgs {
+    schema: GraphQLSchema;
+    document: DocumentNode & ObjectWithGraphQLData;
+    rootValue?: any;
+    contextValue?: any & ObjectWithGraphQLData;
+    variableValues?: Maybe<{
+        [key: string]: any;
+    }>;
+    operationName?: Maybe<string>;
+    fieldResolver?: Maybe<GraphQLFieldResolver<any, any> & OtelPatched>;
+    typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
+}
+export type executeType = executeFunctionWithObj | executeFunctionWithArgs;
+export type parseType = (source: string | Source, options?: ParseOptions) => DocumentNode;
+export type validateType = (schema: GraphQLSchema, documentAST: DocumentNode, rules?: ReadonlyArray<ValidationRule>, options?: {
+    maxErrors?: number;
+}, typeInfo?: TypeInfo) => ReadonlyArray<GraphQLError>;
+export interface GraphQLField {
+    span: Span;
+}
+interface OtelGraphQLData {
+    source?: any;
+    span: Span;
+    fields: {
+        [key: string]: GraphQLField;
+    };
+}
+export interface ObjectWithGraphQLData {
+    [OTEL_GRAPHQL_DATA_SYMBOL]?: OtelGraphQLData;
+}
+export interface OtelPatched {
+    [OTEL_PATCHED_SYMBOL]?: boolean;
+}
+export interface GraphQLPath {
+    prev: GraphQLPath | undefined;
+    key: string | number;
+    /**
+     * optional as it didn't exist yet in ver 14
+     */
+    typename?: string | undefined;
+}
+//# sourceMappingURL=internal-types.d.ts.map

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

@@ -0,0 +1,3 @@
+export declare const OTEL_PATCHED_SYMBOL: unique symbol;
+export declare const OTEL_GRAPHQL_DATA_SYMBOL: unique symbol;
+//# sourceMappingURL=symbols.d.ts.map

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

@@ -0,0 +1,33 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+export interface GraphQLInstrumentationConfig extends InstrumentationConfig {
+    /**
+     * Do not create spans for resolvers.
+     *
+     * @default false
+     */
+    ignoreResolveSpans?: boolean;
+    /**
+     * Don't create spans for the execution of the default resolver on object properties.
+     *
+     * When a resolver function is not defined on the schema for a field, graphql will
+     * use the default resolver which just looks for a property with that name on the object.
+     * If the property is not a function, it's not very interesting to trace.
+     * This option can reduce noise and number of spans created.
+     *
+     * @default false
+     */
+    ignoreTrivialResolveSpans?: boolean;
+    /**
+     * If this is enabled, a `http.server` root span containing the execute span will automatically be renamed
+     * to include the operation name.
+     *
+     * @default false
+     */
+    useOperationNameForRootSpan?: boolean;
+}
+type RequireSpecificKeys<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+export type GraphQLInstrumentationParsedConfig = RequireSpecificKeys<GraphQLInstrumentationConfig, 'ignoreResolveSpans'>;
+export {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,14 @@
+import { DocumentNode, GraphQLFieldResolver, GraphQLObjectType, Location, Maybe } from './graphql-types';
+import { Span } from '@sentry/core';
+import { ObjectWithGraphQLData, OtelPatched } from './internal-types';
+import { GraphQLInstrumentationParsedConfig } from './types';
+export declare const isPromise: (value: any) => value is Promise<unknown>;
+export declare function addSpanSource(span: Span, loc?: Location, start?: number, end?: number): void;
+export declare function endSpan(span: Span, error?: Error): void;
+export declare function getOperation(document: DocumentNode, operationName?: Maybe<string>): DefinitionNodeLike | undefined;
+type DefinitionNodeLike = DocumentNode['definitions'][number];
+export declare function getSourceFromLocation(loc?: Location, inputStart?: number, inputEnd?: number): string;
+export declare function wrapFields(type: Maybe<GraphQLObjectType & OtelPatched>, getConfig: () => GraphQLInstrumentationParsedConfig): void;
+export declare function wrapFieldResolver<TSource = any, TContext = any, TArgs = any>(getConfig: () => GraphQLInstrumentationParsedConfig, fieldResolver: Maybe<GraphQLFieldResolver<TSource, TContext, TArgs> & OtelPatched>, isDefaultResolver?: boolean): GraphQLFieldResolver<TSource, TContext & ObjectWithGraphQLData, TArgs> & OtelPatched;
+export {};
+//# sourceMappingURL=utils.d.ts.map

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

@@ -1,4 +1,4 @@
-import { HapiInstrumentation } from '@opentelemetry/instrumentation-hapi';
+import { HapiInstrumentation } from './vendored/instrumentation';
 import { Server } from './types';
 export declare const instrumentHapi: ((options?: unknown) => HapiInstrumentation) & {
     id: string;
@@ -19,7 +19,9 @@ export declare const instrumentHapi: ((options?: unknown) => HapiInstrumentation
  * })
  * ```
  */
-export declare const hapiIntegration: () => import("@sentry/core").Integration;
+export declare const hapiIntegration: () => import("@sentry/core").Integration & {
+    name: "Hapi";
+};
 export declare const hapiErrorPlugin: {
     name: string;
     version: string;