@sentry/node 10.53.0 → 10.54.0

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

@@ -0,0 +1,63 @@
+import * as api from '@opentelemetry/api';
+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: api.Span;
+}
+interface OtelGraphQLData {
+    source?: any;
+    span: api.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,71 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import * as api from '@opentelemetry/api';
+export interface GraphQLInstrumentationExecutionResponseHook {
+    (span: api.Span, data: any): void;
+}
+export interface GraphQLInstrumentationConfig extends InstrumentationConfig {
+    /**
+     * When set to true it will not remove attributes values from schema source.
+     * By default all values that can be sensitive are removed and replaced
+     * with "*"
+     *
+     * @default false
+     */
+    allowValues?: boolean;
+    /**
+     * The maximum depth of fields/resolvers to instrument.
+     * When set to 0 it will not instrument fields and resolvers
+     *
+     * @default undefined
+     */
+    depth?: number;
+    /**
+     * 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;
+    /**
+     * Place all resolve spans under the same parent instead of producing a nested tree structure.
+     *
+     * @default false
+     */
+    flatResolveSpans?: boolean;
+    /**
+     * Whether to merge list items into a single element.
+     *
+     * @example `users.*.name` instead of `users.0.name`, `users.1.name`
+     *
+     * @default false
+     */
+    mergeItems?: boolean;
+    /**
+     * Hook that allows adding custom span attributes based on the data
+     * returned from "execute" GraphQL action.
+     *
+     * @param data - A GraphQL `ExecutionResult` object. For the exact type definitions, see the following:
+     *  - {@linkcode https://github.com/graphql/graphql-js/blob/v14.7.0/src/execution/execute.js#L115 graphql@14}
+     *  - {@linkcode https://github.com/graphql/graphql-js/blob/15.x.x/src/execution/execute.d.ts#L31 graphql@15}
+     *  - {@linkcode https://github.com/graphql/graphql-js/blob/16.x.x/src/execution/execute.ts#L127 graphql@16}
+     *
+     * @default undefined
+     */
+    responseHook?: GraphQLInstrumentationExecutionResponseHook;
+}
+type RequireSpecificKeys<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+export type GraphQLInstrumentationParsedConfig = RequireSpecificKeys<GraphQLInstrumentationConfig, 'mergeItems' | 'depth' | 'allowValues' | 'ignoreResolveSpans'>;
+export {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,17 @@
+import { DocumentNode, GraphQLFieldResolver, GraphQLObjectType, Location, Maybe } from './graphql-types';
+import * as api from '@opentelemetry/api';
+import { ObjectWithGraphQLData, OtelPatched } from './internal-types';
+import { GraphQLInstrumentationParsedConfig } from './types';
+export declare const isPromise: (value: any) => value is Promise<unknown>;
+export declare function addInputVariableAttributes(span: api.Span, variableValues: {
+    [key: string]: any;
+}): void;
+export declare function addSpanSource(span: api.Span, loc?: Location, allowValues?: boolean, start?: number, end?: number): void;
+export declare function endSpan(span: api.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, allowValues?: boolean, inputStart?: number, inputEnd?: number): string;
+export declare function wrapFields(type: Maybe<GraphQLObjectType & OtelPatched>, tracer: api.Tracer, getConfig: () => GraphQLInstrumentationParsedConfig): void;
+export declare function wrapFieldResolver<TSource = any, TContext = any, TArgs = any>(tracer: api.Tracer, 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;

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

@@ -0,0 +1,6 @@
+export declare enum AttributeNames {
+    HAPI_TYPE = "hapi.type",
+    PLUGIN_NAME = "hapi.plugin.name",
+    EXT_TYPE = "server.ext.type"
+}
+//# sourceMappingURL=AttributeNames.d.ts.map

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

@@ -0,0 +1,70 @@
+export type ServerOptions = Record<string, any>;
+export declare function server(options?: ServerOptions): Server;
+export declare function Server(options?: ServerOptions): Server;
+export type ServerRequestExtType = 'onPreAuth' | 'onCredentials' | 'onPostAuth' | 'onPreHandler' | 'onPostHandler' | 'onPreResponse' | 'onRequest';
+export declare namespace Lifecycle {
+    type Method = (request: any, h: any, err?: Error) => ReturnValue;
+    type ReturnValue = any;
+    type FailAction = 'error' | 'log' | 'ignore' | Method;
+}
+export interface ServerRoute<T = any> {
+    path: string;
+    method: string;
+    handler?: Lifecycle.Method | T;
+    options?: ((server: Server) => ServerRouteOptions) | ServerRouteOptions;
+    [key: string]: any;
+}
+interface ServerRouteOptions {
+    handler?: Lifecycle.Method | any;
+    [key: string]: any;
+}
+export interface Server {
+    route: (...args: any[]) => any;
+    ext: (...args: any[]) => any;
+    register: (...args: any[]) => any;
+    [key: string]: any;
+}
+export interface Plugin<T, _V = void> {
+    register: (server: Server, options: T) => void | Promise<void>;
+    name?: string;
+    pkg?: {
+        name: string;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+export interface PluginNameVersion {
+    name: string;
+    [key: string]: any;
+}
+export interface PluginPackage {
+    pkg: {
+        name: string;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+export interface ServerRegisterPluginObject<T> {
+    plugin: Plugin<T, void> | {
+        plugin: Plugin<T, void>;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+export interface ServerRegisterOptions {
+    [key: string]: any;
+}
+export interface ServerExtEventsObject {
+    type: string;
+    [key: string]: any;
+}
+export interface ServerExtEventsRequestObject {
+    type: ServerRequestExtType;
+    method: Lifecycle.Method;
+    [key: string]: any;
+}
+export interface ServerExtOptions {
+    [key: string]: any;
+}
+export {};
+//# sourceMappingURL=hapi-types.d.ts.map

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

@@ -0,0 +1,72 @@
+import { InstrumentationBase, InstrumentationConfig, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+/** Hapi instrumentation for OpenTelemetry */
+export declare class HapiInstrumentation extends InstrumentationBase {
+    private _semconvStability;
+    constructor(config?: InstrumentationConfig);
+    protected init(): InstrumentationNodeModuleDefinition;
+    /**
+     * Patches the Hapi.server and Hapi.Server functions in order to instrument
+     * the server.route, server.ext, and server.register functions via calls to the
+     * @function _getServerRoutePatch, @function _getServerExtPatch, and
+     * @function _getServerRegisterPatch functions
+     * @param original - the original Hapi Server creation function
+     */
+    private _getServerPatch;
+    /**
+     * Patches the plugin register function used by the Hapi Server. This function
+     * goes through each plugin that is being registered and adds instrumentation
+     * via a call to the @function _wrapRegisterHandler function.
+     * @param {RegisterFunction<T>} original - the original register function which
+     * registers each plugin on the server
+     */
+    private _getServerRegisterPatch;
+    /**
+     * Patches the Server.ext function which adds extension methods to the specified
+     * point along the request lifecycle. This function accepts the full range of
+     * accepted input into the standard Hapi `server.ext` function. For each extension,
+     * it adds instrumentation to the handler via a call to the @function _wrapExtMethods
+     * function.
+     * @param original - the original ext function which adds the extension method to the server
+     * @param {string} [pluginName] - if present, represents the name of the plugin responsible
+     * for adding this server extension. Else, signifies that the extension was added directly
+     */
+    private _getServerExtPatch;
+    /**
+     * Patches the Server.route function. This function accepts either one or an array
+     * of Hapi.ServerRoute objects and adds instrumentation on each route via a call to
+     * the @function _wrapRouteHandler function.
+     * @param {HapiServerRouteInputMethod} original - the original route function which adds
+     * the route to the server
+     * @param {string} [pluginName] - if present, represents the name of the plugin responsible
+     * for adding this server route. Else, signifies that the route was added directly
+     */
+    private _getServerRoutePatch;
+    /**
+     * Wraps newly registered plugins to add instrumentation to the plugin's clone of
+     * the original server. Specifically, wraps the server.route and server.ext functions
+     * via calls to @function _getServerRoutePatch and @function _getServerExtPatch
+     * @param {Hapi.Plugin<T>} plugin - the new plugin which is being instrumented
+     */
+    private _wrapRegisterHandler;
+    /**
+     * Wraps request extension methods to add instrumentation to each new extension handler.
+     * Patches each individual extension in order to create the
+     * span and propagate context. It does not create spans when there is no parent span.
+     * @param {PatchableExtMethod | PatchableExtMethod[]} method - the request extension
+     * handler which is being instrumented
+     * @param {Hapi.ServerRequestExtType} extPoint - the point in the Hapi request lifecycle
+     * which this extension targets
+     * @param {string} [pluginName] - if present, represents the name of the plugin responsible
+     * for adding this server route. Else, signifies that the route was added directly
+     */
+    private _wrapExtMethods;
+    /**
+     * Patches each individual route handler method in order to create the
+     * span and propagate context. It does not create spans when there is no parent span.
+     * @param {PatchableServerRoute} route - the route handler which is being instrumented
+     * @param {string} [pluginName] - if present, represents the name of the plugin responsible
+     * for adding this server route. Else, signifies that the route was added directly
+     */
+    private _wrapRouteHandler;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1,32 @@
+import * as Hapi from './hapi-types';
+export declare const HapiComponentName = "@hapi/hapi";
+/**
+ * This symbol is used to mark a Hapi route handler or server extension handler as
+ * already patched, since its possible to use these handlers multiple times
+ * i.e. when allowing multiple versions of one plugin, or when registering a plugin
+ * multiple times on different servers.
+ */
+export declare const handlerPatched: unique symbol;
+export type HapiServerRouteInputMethod = (route: HapiServerRouteInput) => void;
+export type HapiServerRouteInput = PatchableServerRoute | PatchableServerRoute[];
+export type PatchableServerRoute = Hapi.ServerRoute<any> & {
+    [handlerPatched]?: boolean;
+};
+export type HapiPluginObject<T> = Hapi.ServerRegisterPluginObject<T>;
+export type HapiPluginInput<T> = HapiPluginObject<T> | Array<HapiPluginObject<T>>;
+export type RegisterFunction<T> = (plugin: HapiPluginInput<T>, options?: Hapi.ServerRegisterOptions) => Promise<void>;
+export type PatchableExtMethod = Hapi.Lifecycle.Method & {
+    [handlerPatched]?: boolean;
+};
+export type ServerExtDirectInput = [
+    Hapi.ServerRequestExtType,
+    Hapi.Lifecycle.Method,
+    (Hapi.ServerExtOptions | undefined)?
+];
+export declare const HapiLayerType: {
+    ROUTER: string;
+    PLUGIN: string;
+    EXT: string;
+};
+export declare const HapiLifecycleMethodNames: Set<string>;
+//# sourceMappingURL=internal-types.d.ts.map

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

@@ -0,0 +1,13 @@
+/**
+ * Deprecated, use `http.request.method` instead.
+ *
+ * @example GET
+ * @example POST
+ * @example HEAD
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `http.request.method`.
+ */
+export declare const ATTR_HTTP_METHOD: "http.method";
+//# sourceMappingURL=semconv.d.ts.map

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

@@ -0,0 +1,19 @@
+import { Attributes } from '@opentelemetry/api';
+import * as Hapi from './hapi-types';
+import { HapiPluginObject, PatchableExtMethod, ServerExtDirectInput } from './internal-types';
+import { SemconvStability } from '@opentelemetry/instrumentation';
+export declare function getPluginName<T>(plugin: Hapi.Plugin<T>): string;
+export declare const isLifecycleExtType: (variableToCheck: unknown) => variableToCheck is Hapi.ServerRequestExtType;
+export declare const isLifecycleExtEventObj: (variableToCheck: unknown) => variableToCheck is Hapi.ServerExtEventsRequestObject;
+export declare const isDirectExtInput: (variableToCheck: unknown) => variableToCheck is ServerExtDirectInput;
+export declare const isPatchableExtMethod: (variableToCheck: PatchableExtMethod | PatchableExtMethod[]) => variableToCheck is PatchableExtMethod;
+export declare const getRouteMetadata: (route: Hapi.ServerRoute, semconvStability: SemconvStability, pluginName?: string) => {
+    attributes: Attributes;
+    name: string;
+};
+export declare const getExtMetadata: (extPoint: Hapi.ServerRequestExtType, pluginName?: string, methodName?: string) => {
+    attributes: Attributes;
+    name: string;
+};
+export declare const getPluginFromInput: <T>(pluginObj: HapiPluginObject<T>) => Hapi.Plugin<T, void>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -1,4 +1,4 @@
-import { KafkaJsInstrumentation } from '@opentelemetry/instrumentation-kafkajs';
+import { KafkaJsInstrumentation } from './vendored/instrumentation';
 export declare const instrumentKafka: ((options?: unknown) => KafkaJsInstrumentation) & {
     id: string;
 };
@@ -16,4 +16,4 @@ export declare const instrumentKafka: ((options?: unknown) => KafkaJsInstrumenta
  * });
  */
 export declare const kafkaIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=kafka.d.ts.map
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,25 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { KafkaJsInstrumentationConfig } from './types';
+export declare class KafkaJsInstrumentation extends InstrumentationBase<KafkaJsInstrumentationConfig> {
+    private _clientDuration;
+    private _sentMessages;
+    private _consumedMessages;
+    private _processDuration;
+    constructor(config?: KafkaJsInstrumentationConfig);
+    _updateMetricInstruments(): void;
+    protected init(): InstrumentationNodeModuleDefinition;
+    private _getConsumerPatch;
+    private _setKafkaEventListeners;
+    private _recordClientDurationMetric;
+    private _getProducerPatch;
+    private _getConsumerRunPatch;
+    private _getConsumerEachMessagePatch;
+    private _getConsumerEachBatchPatch;
+    private _getProducerTransactionPatch;
+    private _getSendBatchPatch;
+    private _getSendPatch;
+    private _endSpansOnPromise;
+    private _startConsumerSpan;
+    private _startProducerSpan;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1,9 @@
+import { Consumer, Producer } from './kafkajs-types';
+export declare const EVENT_LISTENERS_SET: unique symbol;
+export interface ConsumerExtended extends Consumer {
+    [EVENT_LISTENERS_SET]?: boolean;
+}
+export interface ProducerExtended extends Producer {
+    [EVENT_LISTENERS_SET]?: boolean;
+}
+//# sourceMappingURL=internal-types.d.ts.map

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

@@ -0,0 +1,111 @@
+export interface InstrumentationEvent<T> {
+    id: string;
+    type: string;
+    timestamp: number;
+    payload: T;
+}
+export type RequestEvent = InstrumentationEvent<{
+    apiKey: number;
+    apiName: string;
+    apiVersion: number;
+    broker: string;
+    clientId: string;
+    correlationId: number;
+    createdAt: number;
+    duration: number;
+    pendingDuration: number;
+    sentAt: number;
+    size: number;
+}>;
+export type RemoveInstrumentationEventListener<_T> = () => void;
+export type ConsumerEvents = {
+    REQUEST: 'consumer.network.request';
+    [key: string]: string;
+};
+export type ProducerEvents = {
+    REQUEST: 'producer.network.request';
+    [key: string]: string;
+};
+type Sender = {
+    send(record: any): Promise<any>;
+    sendBatch(batch: any): Promise<any>;
+};
+export type Producer = Sender & {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isIdempotent(): boolean;
+    readonly events: ProducerEvents;
+    on(eventName: string, listener: (...args: any[]) => void): RemoveInstrumentationEventListener<any>;
+    transaction(): Promise<Transaction>;
+    [key: string]: any;
+};
+export type Transaction = Sender & {
+    sendOffsets(offsets: any): Promise<void>;
+    commit(): Promise<void>;
+    abort(): Promise<void>;
+    isActive(): boolean;
+};
+export type Consumer = {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    subscribe(subscription: any): Promise<void>;
+    run(config?: any): Promise<void>;
+    readonly events: ConsumerEvents;
+    on(eventName: string, listener: (...args: any[]) => void): RemoveInstrumentationEventListener<any>;
+    [key: string]: any;
+};
+export declare class Kafka {
+    consumer(config: any): Consumer;
+    producer(config?: any): Producer;
+    [key: string]: any;
+}
+export interface Message {
+    key?: Buffer | string | null;
+    value: Buffer | string | null;
+    partition?: number;
+    headers?: Record<string, Buffer | string | (Buffer | string)[] | undefined>;
+    timestamp?: string;
+}
+export type KafkaMessage = {
+    [key: string]: any;
+} & Message;
+export type RecordMetadata = {
+    topicName: string;
+    partition: number;
+    errorCode: number;
+    offset?: string;
+    timestamp?: string;
+    baseOffset?: string;
+    logAppendTime?: string;
+    logStartOffset?: string;
+};
+export interface EachMessagePayload {
+    topic: string;
+    partition: number;
+    message: KafkaMessage;
+    heartbeat(): Promise<void>;
+    pause(): () => void;
+}
+export interface EachBatchPayload {
+    batch: any;
+    resolveOffset(offset: string): void;
+    heartbeat(): Promise<void>;
+    pause(): () => void;
+    commitOffsetsIfNecessary(offsets?: any): Promise<void>;
+    uncommittedOffsets(): any;
+    isRunning(): boolean;
+    isStale(): boolean;
+}
+export type EachMessageHandler = (payload: EachMessagePayload) => Promise<void>;
+export type EachBatchHandler = (payload: EachBatchPayload) => Promise<void>;
+export type ConsumerRunConfig = {
+    autoCommit?: boolean;
+    autoCommitInterval?: number | null;
+    autoCommitThreshold?: number | null;
+    eachBatchAutoResolve?: boolean;
+    partitionsConsumedConcurrently?: number;
+    eachBatch?: EachBatchHandler;
+    eachMessage?: EachMessageHandler;
+};
+export {};
+//# sourceMappingURL=kafkajs-types.d.ts.map

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

@@ -0,0 +1,3 @@
+import { TextMapGetter } from '@opentelemetry/api';
+export declare const bufferTextMapGetter: TextMapGetter;
+//# sourceMappingURL=propagator.d.ts.map