@sentry/node 10.53.0 → 10.54.0

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

@@ -0,0 +1,130 @@
+import { Span } from '@opentelemetry/api';
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+export interface PublishInfo {
+    moduleVersion: string | undefined;
+    exchange: string;
+    routingKey: string;
+    content: Buffer;
+    options?: AmqplibPublishOptions;
+    isConfirmChannel?: boolean;
+}
+export interface PublishConfirmedInfo extends PublishInfo {
+    confirmError?: any;
+}
+export interface ConsumeInfo {
+    moduleVersion: string | undefined;
+    msg: ConsumeMessage;
+}
+export interface ConsumeEndInfo {
+    msg: ConsumeMessage;
+    rejected: boolean | null;
+    endOperation: EndOperation;
+}
+export interface AmqplibPublishCustomAttributeFunction {
+    (span: Span, publishInfo: PublishInfo): void;
+}
+export interface AmqplibPublishConfirmCustomAttributeFunction {
+    (span: Span, publishConfirmedInto: PublishConfirmedInfo): void;
+}
+export interface AmqplibConsumeCustomAttributeFunction {
+    (span: Span, consumeInfo: ConsumeInfo): void;
+}
+export interface AmqplibConsumeEndCustomAttributeFunction {
+    (span: Span, consumeEndInfo: ConsumeEndInfo): void;
+}
+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 AmqplibInstrumentationConfig extends InstrumentationConfig {
+    /** hook for adding custom attributes before publish message is sent */
+    publishHook?: AmqplibPublishCustomAttributeFunction;
+    /** hook for adding custom attributes after publish message is confirmed by the broker */
+    publishConfirmHook?: AmqplibPublishConfirmCustomAttributeFunction;
+    /** hook for adding custom attributes before consumer message is processed */
+    consumeHook?: AmqplibConsumeCustomAttributeFunction;
+    /** hook for adding custom attributes after consumer message is acked to server */
+    consumeEndHook?: AmqplibConsumeEndCustomAttributeFunction;
+    /**
+     * When user is setting up consume callback, it is user's responsibility to call
+     * ack/nack etc on the msg to resolve it in the server.
+     * If user is not calling the ack, the message will stay in the queue until
+     * channel is closed, or until server timeout expires (if configured).
+     * While we wait for the ack, a reference to the message is stored in plugin, which
+     * will never be garbage collected.
+     * To prevent memory leak, plugin has it's own configuration of timeout, which
+     * will close the span if user did not call ack after this timeout.
+     * If timeout is not big enough, span might be closed with 'InstrumentationTimeout',
+     * and then received valid ack from the user later which will not be instrumented.
+     *
+     * Default is 1 minute
+     */
+    consumeTimeoutMs?: number;
+    /** option to use a span link for the consume message instead of continuing a trace */
+    useLinksForConsume?: boolean;
+}
+export declare const DEFAULT_CONFIG: AmqplibInstrumentationConfig;
+export interface AmqplibPublishOptions {
+    expiration?: string | number;
+    userId?: string;
+    CC?: string | string[];
+    mandatory?: boolean;
+    persistent?: boolean;
+    deliveryMode?: boolean | number;
+    BCC?: string | string[];
+    contentType?: string;
+    contentEncoding?: string;
+    headers?: any;
+    priority?: number;
+    correlationId?: string;
+    replyTo?: string;
+    messageId?: string;
+    timestamp?: number;
+    type?: string;
+    appId?: string;
+}
+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

@@ -0,0 +1,35 @@
+import { Context, HrTime, Span, Attributes } from '@opentelemetry/api';
+import { SemconvStability } from '@opentelemetry/instrumentation';
+import { Connection, Channel, ConfirmChannel, 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 type InstrumentationConnection = Connection & {
+    [CONNECTION_ATTRIBUTES]?: Attributes;
+};
+export type InstrumentationPublishChannel = (Channel | ConfirmChannel) & {
+    connection: InstrumentationConnection;
+};
+export type InstrumentationConsumeChannel = Channel & {
+    connection: InstrumentationConnection;
+    [CHANNEL_SPANS_NOT_ENDED]?: {
+        msg: ConsumeMessage;
+        timeOfConsume: HrTime;
+    }[];
+    [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) => Attributes;
+export declare const getConnectionAttributesFromUrl: (url: string | Options.Connect, netSemconvStability: SemconvStability) => Attributes;
+export declare const markConfirmChannelTracing: (context: Context) => Context;
+export declare const unmarkConfirmChannelTracing: (context: Context) => Context;
+export declare const isConfirmChannelTracing: (context: Context) => boolean;
+//# sourceMappingURL=utils.d.ts.map

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;
 };
@@ -43,4 +43,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,13 @@
+export declare enum AttributeNames {
+    CONNECT_TYPE = "connect.type",
+    CONNECT_NAME = "connect.name"
+}
+export declare enum ConnectTypes {
+    MIDDLEWARE = "middleware",
+    REQUEST_HANDLER = "request_handler"
+}
+export declare enum ConnectNames {
+    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 { Span } from '@opentelemetry/api';
+import { HandleFunction, NextFunction, Server, Use } from './internal-types';
+import { InstrumentationBase, InstrumentationConfig, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+export declare const ANONYMOUS_NAME = "anonymous";
+/** Connect instrumentation for OpenTelemetry */
+export declare class ConnectInstrumentation extends InstrumentationBase {
+    constructor(config?: InstrumentationConfig);
+    init(): InstrumentationNodeModuleDefinition[];
+    private _patchApp;
+    private _patchConstructor;
+    _patchNext(next: NextFunction, 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?: any) => 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: any, 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;
 };
@@ -17,4 +17,4 @@ export declare const instrumentDataloader: ((options?: unknown) => DataloaderIns
  * ```
  */
 export declare const dataloaderIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=dataloader.d.ts.map
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,14 @@
+declare class DataLoader<K, V, _C = K> {
+    constructor(batchLoadFn: DataLoader.BatchLoadFn<K, V>, options?: any);
+    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;
+    [key: string]: any;
+}
+declare namespace DataLoader {
+    type BatchLoadFn<K, V> = (keys: ReadonlyArray<K>) => PromiseLike<ArrayLike<V | Error>>;
+}
+export = DataLoader;
+//# sourceMappingURL=dataloader-types.d.ts.map

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

@@ -0,0 +1,21 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { DataloaderInstrumentationConfig } from './types';
+export declare class DataloaderInstrumentation extends InstrumentationBase<DataloaderInstrumentationConfig> {
+    constructor(config?: DataloaderInstrumentationConfig);
+    protected init(): InstrumentationNodeModuleDefinition[];
+    private shouldCreateSpans;
+    private getSpanName;
+    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,10 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+export interface DataloaderInstrumentationConfig extends InstrumentationConfig {
+    /**
+     * Whether the instrumentation requires a parent span, if set to true
+     * and there is no parent span, no additional spans are created
+     * (default: true)
+     */
+    requireParentSpan?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,27 @@
+import { Span } from '@opentelemetry/api';
+import { InstrumentationBase, InstrumentationConfig } from '@opentelemetry/instrumentation';
+declare const kRecordExceptions: unique symbol;
+export interface FastifyOtelInstrumentationOpts extends InstrumentationConfig {
+    registerOnInitialization?: boolean;
+    requestHook?: (span: Span, request: any) => void;
+    lifecycleHook?: (span: Span, info: {
+        hookName: string;
+        request: any;
+        handler?: string;
+    }) => void;
+    recordExceptions?: boolean;
+}
+export declare class FastifyOtelInstrumentation extends InstrumentationBase<FastifyOtelInstrumentationOpts> {
+    _otelLogger: any;
+    _requestHook: ((span: Span, request: any) => void) | null;
+    _lifecycleHook: ((span: Span, info: any) => void) | null;
+    _handleInitialization: ((message: any) => void) | undefined;
+    [kRecordExceptions]: boolean;
+    constructor(config?: FastifyOtelInstrumentationOpts);
+    enable(): any;
+    disable(): any;
+    init(): never[];
+    plugin(): any;
+}
+export {};
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -1,20 +1,20 @@
-import { GenericPoolInstrumentation } from '@opentelemetry/instrumentation-generic-pool';
-export declare const instrumentGenericPool: ((options?: unknown) => GenericPoolInstrumentation) & {
-    id: string;
-};
-/**
- * Adds Sentry tracing instrumentation for the [generic-pool](https://www.npmjs.com/package/generic-pool) library.
- *
- * For more information, see the [`genericPoolIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/genericpool/).
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- *
- * Sentry.init({
- *  integrations: [Sentry.genericPoolIntegration()],
- * });
- * ```
- */
-export declare const genericPoolIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=genericPool.d.ts.map
+import { GenericPoolInstrumentation } from './vendored/instrumentation';
+export declare const instrumentGenericPool: ((options?: unknown) => GenericPoolInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [generic-pool](https://www.npmjs.com/package/generic-pool) library.
+ *
+ * For more information, see the [`genericPoolIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/genericpool/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.genericPoolIntegration()],
+ * });
+ * ```
+ */
+export declare const genericPoolIntegration: () => import("@sentry/core").Integration;
+//# 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]: any;
+}
+//# sourceMappingURL=generic-pool-types.d.ts.map

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

@@ -0,0 +1,10 @@
+import { InstrumentationBase, InstrumentationConfig, 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/{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.
@@ -45,4 +45,4 @@ export declare const instrumentGraphql: ((options: GraphqlOptions) => GraphQLIns
  */
 export declare const graphqlIntegration: (options?: GraphqlOptions | undefined) => import("@sentry/core").Integration;
 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,12 @@
+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",
+    VARIABLES = "graphql.variables.",
+    ERROR_VALIDATION_NAME = "graphql.validation.error"
+}
+//# sourceMappingURL=AttributeNames.d.ts.map

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

@@ -0,0 +1,136 @@
+export type PromiseOrValue<T> = T | Promise<T>;
+export type Maybe<T> = null | undefined | T;
+export interface Location {
+    start: number;
+    end: number;
+    startToken: Token;
+    source: Source;
+    [key: string]: any;
+}
+export interface Token {
+    kind: string;
+    start: number;
+    end: number;
+    line: number;
+    column: number;
+    value: string;
+    prev: Token | null;
+    next: Token | null;
+    [key: string]: any;
+}
+export interface Source {
+    body: string;
+    name: string;
+    locationOffset: Location;
+    [key: string]: any;
+}
+export interface DocumentNode {
+    kind: string;
+    definitions: ReadonlyArray<DefinitionNode>;
+    loc?: Location;
+    [key: string]: any;
+}
+export interface DefinitionNode {
+    kind: string;
+    loc?: Location;
+    [key: string]: any;
+}
+export interface OperationDefinitionNode extends DefinitionNode {
+    operation: string;
+    name?: {
+        kind: string;
+        value: string;
+        loc?: Location;
+    };
+    [key: string]: any;
+}
+export interface ParseOptions {
+    noLocation?: boolean;
+    [key: string]: any;
+}
+export interface ExecutionArgs {
+    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>>;
+    [key: string]: any;
+}
+export interface ExecutionResult {
+    errors?: ReadonlyArray<GraphQLError>;
+    data?: Record<string, any> | null;
+    [key: string]: any;
+}
+export interface GraphQLError {
+    message: string;
+    locations?: ReadonlyArray<{
+        line: number;
+        column: number;
+    }>;
+    path?: ReadonlyArray<string | number>;
+    [key: string]: any;
+}
+export interface GraphQLSchema {
+    getQueryType(): GraphQLObjectType | undefined | null;
+    getMutationType(): GraphQLObjectType | undefined | null;
+    [key: string]: any;
+}
+export interface GraphQLObjectType {
+    name: string;
+    getFields(): {
+        [key: string]: GraphQLField;
+    };
+    [key: string]: any;
+}
+export interface GraphQLField {
+    name: string;
+    type: GraphQLOutputType;
+    resolve?: GraphQLFieldResolver<any, any>;
+    [key: string]: any;
+}
+export type GraphQLOutputType = GraphQLNamedOutputType | GraphQLWrappingType;
+interface GraphQLNamedOutputType {
+    name: string;
+    [key: string]: any;
+}
+interface GraphQLWrappingType {
+    ofType: GraphQLOutputType;
+    [key: string]: any;
+}
+export interface GraphQLUnionType {
+    name: string;
+    getTypes(): ReadonlyArray<GraphQLObjectType>;
+    [key: string]: any;
+}
+export type GraphQLType = GraphQLOutputType | GraphQLUnionType;
+export type GraphQLFieldResolver<TSource, TContext, TArgs = any> = (source: TSource, args: TArgs, context: TContext, info: GraphQLResolveInfo) => any;
+export type GraphQLTypeResolver<TSource, TContext> = (value: TSource, context: TContext, info: GraphQLResolveInfo, abstractType: any) => any;
+export interface GraphQLResolveInfo {
+    fieldName: string;
+    fieldNodes: ReadonlyArray<{
+        kind: string;
+        loc?: Location;
+        [key: string]: any;
+    }>;
+    returnType: {
+        toString(): string;
+        [key: string]: any;
+    };
+    parentType: {
+        name: string;
+        [key: string]: any;
+    };
+    path: any;
+    [key: string]: any;
+}
+export type ValidationRule = any;
+export interface TypeInfo {
+    [key: string]: any;
+}
+export {};
+//# sourceMappingURL=graphql-types.d.ts.map

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

@@ -0,0 +1,20 @@
+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;
+    private _executeResponseHook;
+    private _patchParse;
+    private _patchValidate;
+    private _parse;
+    private _validate;
+    private _createExecuteSpan;
+    private _wrapExecuteArgs;
+}
+//# sourceMappingURL=instrumentation.d.ts.map