@graphql-hive/plugin-opentelemetry 1.0.0-alpha-2cea6e8a62aea3e45963d47c35cb6db588d78c54

package/dist/plugin-Cn24wGGV.d.ts

@@ -0,0 +1,184 @@
+import { GatewayConfigContext, GatewayPlugin } from '@graphql-hive/gateway-runtime';
+import { ExecutionRequest } from '@graphql-tools/utils';
+import { Tracer, Context } from '@opentelemetry/api';
+import { DocumentNode, GraphQLSchema } from 'graphql';
+
+type OperationHashingFn = (input: {
+    document: DocumentNode;
+    operationName?: string | null;
+    variableValues?: Record<string, unknown> | null;
+    schema: GraphQLSchema;
+}) => string | null;
+
+type BooleanOrPredicate<TInput = never> = boolean | ((input: TInput) => boolean);
+type OpenTelemetryGatewayPluginOptions = {
+    /**
+     * Whether to rely on OTEL context api for span correlation.
+     *  - `true`: the plugin will rely on OTEL context manager for span parenting.
+     *  - `false`: the plugin will rely on request context for span parenting,
+     *    which implies that parenting with user defined may be broken.
+     *
+     * By default, it is enabled if the registered Context Manager is compatible with async calls,
+     * or if it is possible to register an `AsyncLocalStorageContextManager`.
+     *
+     * Note: If `true`, an error is thrown if it fails to obtain an async calls compatible Context Manager.
+     */
+    useContextManager?: boolean;
+    /**
+     * Whether to inherit the context from the calling service (default: true).
+     *
+     * This process is done by extracting the context from the incoming request headers. If disabled, a new context and a trace-id will be created.
+     *
+     * See https://opentelemetry.io/docs/languages/js/propagation/
+     */
+    inheritContext?: boolean;
+    /**
+     * Whether to propagate the context to the outgoing requests (default: true).
+     *
+     * This process is done by injecting the context into the outgoing request headers. If disabled, the context will not be propagated.
+     *
+     * See https://opentelemetry.io/docs/languages/js/propagation/
+     */
+    propagateContext?: boolean;
+    /**
+     * Configure Opentelemetry `diag` API to use Gateway's logger.
+     *
+     * @default true
+     *
+     * Note: Logger configuration respects OTEL environment variables standard.
+     *       This means that the logger will be enabled only if `OTEL_LOG_LEVEL` variable is set.
+     */
+    configureDiagLogger?: boolean;
+    /**
+     * The TraceProvider method to call on Gateway's disposal. By default, it tries to run `forceFlush` method on
+     * the registered trace provider if it exists.
+     * Set to `false` to disable this behavior.
+     * @default 'forceFlush'
+     */
+    flushOnDispose?: string | false;
+    /**
+     * Function to be used to compute the hash of each operation (graphql.operation.hash attribute).
+     * Note: pass `null` to disable operation hashing
+     *
+     * @default `hashOperation` from @graphql-hive/core
+     */
+    hashOperation?: OperationHashingFn | null;
+    /**
+     * Tracing configuration
+     */
+    traces?: boolean | {
+        /**
+         * Tracer instance to use for creating spans (default: a tracer with name 'gateway').
+         */
+        tracer?: Tracer;
+        /**
+         * Options to control which spans to create.
+         * By default, all spans are enabled.
+         *
+         * You may specify a boolean value to enable/disable all spans, or a function to dynamically enable/disable spans based on the input.
+         */
+        spans?: {
+            /**
+             * Enable/disable HTTP request spans (default: true).
+             *
+             * Disabling the HTTP span will also disable all other child spans.
+             */
+            http?: BooleanOrPredicate<{
+                request: Request;
+            }>;
+            /**
+             * Enable/disable GraphQL operation spans (default: true).
+             *
+             * Disabling the GraphQL operation spa will also disable all other child spans.
+             */
+            graphql?: BooleanOrPredicate<{
+                context: unknown;
+            }>;
+            /**
+             * Enable/disable GraphQL context building phase (default: true).
+             */
+            graphqlContextBuilding?: BooleanOrPredicate<{
+                context: unknown;
+            }>;
+            /**
+             * Enable/disable GraphQL parse spans (default: true).
+             */
+            graphqlParse?: BooleanOrPredicate<{
+                context: unknown;
+            }>;
+            /**
+             * Enable/disable GraphQL validate spans (default: true).
+             */
+            graphqlValidate?: BooleanOrPredicate<{
+                context: unknown;
+            }>;
+            /**
+             * Enable/disable GraphQL execute spans (default: true).
+             *
+             * Disabling the GraphQL execute spans will also disable all other child spans.
+             */
+            graphqlExecute?: BooleanOrPredicate<{
+                context: unknown;
+            }>;
+            /**
+             * Enable/disable subgraph execute spans (default: true).
+             *
+             * Disabling the subgraph execute spans will also disable all other child spans.
+             */
+            subgraphExecute?: BooleanOrPredicate<{
+                executionRequest: ExecutionRequest;
+                subgraphName: string;
+            }>;
+            /**
+             * Enable/disable upstream HTTP fetch calls spans (default: true).
+             */
+            upstreamFetch?: BooleanOrPredicate<{
+                executionRequest: ExecutionRequest | undefined;
+            }>;
+            /**
+             * Enable/disable schema loading spans (default: true if context manager available).
+             *
+             * Note: This span requires an Async compatible context manager
+             */
+            schema?: boolean;
+            /**
+             * Enable/disable initialization span (default: true).
+             */
+            initialization?: boolean;
+        };
+        events?: {
+            /**
+             * Enable/Disable cache related span events (default: true).
+             */
+            cache?: BooleanOrPredicate<{
+                key: string;
+                action: 'read' | 'write';
+            }>;
+        };
+    };
+};
+type ContextMatcher = {
+    request?: Request;
+    context?: any;
+    executionRequest?: ExecutionRequest;
+};
+type OpenTelemetryPluginUtils = {
+    tracer: Tracer;
+    getActiveContext: (payload: ContextMatcher) => Context;
+    getHttpContext: (request: Request) => Context | undefined;
+    getOperationContext: (context: any) => Context | undefined;
+    getExecutionRequestContext: (ExecutionRequest: ExecutionRequest) => Context | undefined;
+};
+type OpenTelemetryContextExtension = {
+    openTelemetry: {
+        tracer: Tracer;
+        getActiveContext: (payload?: ContextMatcher) => Context;
+        getHttpContext: (request?: Request) => Context | undefined;
+        getOperationContext: (context?: any) => Context | undefined;
+        getExecutionRequestContext: (ExecutionRequest: ExecutionRequest) => Context | undefined;
+    };
+};
+type OpenTelemetryPlugin = GatewayPlugin<OpenTelemetryContextExtension> & OpenTelemetryPluginUtils;
+declare function useOpenTelemetry(options: OpenTelemetryGatewayPluginOptions & Partial<GatewayConfigContext>): OpenTelemetryPlugin;
+
+export { type OpenTelemetryContextExtension as O, type OpenTelemetryGatewayPluginOptions as a, type OpenTelemetryPlugin as b, type OpenTelemetryPluginUtils as c, useOpenTelemetry as u };