@hypertestco/node-sdk-v3 0.0.1-8

package/instrumentation/helpers/outboundClusterPathConfigFromUsers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This allows user to provide us the custom cluster path,
+ * this is useful in scenarios when we are not able to identify the path pattern
+ * and deduplication fails.
+ *
+ * IMPORTANT!
+ * The patterns provided here are preceded by the pattern we get from downstream services response headers
+ */
+export declare const setOutboundHttpRequestPathPatterns: (pathPatterns: string[]) => void;
+/**
+ * This is a fallback option if we ever have to prioritize custom cluster paths over
+ * the pattern we get from downstream services response headers
+ */
+export declare const setHighPriorityOutboundHttpRequestPathPatterns: (pathPatterns: string[]) => void;

package/instrumentation/helpers/samplingLogic.d.ts

@@ -0,0 +1,112 @@
+import type { IncomingHttpHeaders } from 'http';
+import type * as GrpcModule from '@grpc/grpc-js';
+import type * as Amqp from 'amqplib';
+import type * as KafkaJs from 'kafkajs';
+import type { HttpMethodEnum } from '../../../../utils/types';
+export declare enum SamplingMode {
+    BLOCK_LOCAL = "BLOCK_LOCAL",
+    RECORD_LOCAL = "RECORD_LOCAL",
+    RECORD_TRACE = "RECORD_TRACE"
+}
+type SamplingConfig = {
+    http?: {
+        path: string | RegExp;
+        method?: string;
+        samplingRate?: number;
+        maxResponseTimeMs?: number;
+        coolOffPeriodMs?: number;
+        useAdaptiveSampling?: boolean;
+    }[];
+    grpc?: {
+        service: string | '*';
+        method: string | '*';
+        samplingRate?: number;
+        maxResponseTimeMs?: number;
+        coolOffPeriodMs?: number;
+        useAdaptiveSampling?: boolean;
+    }[];
+    kafka?: {
+        groupId: string | '*';
+        topic: string | '*';
+        samplingRate?: number;
+        maxResponseTimeMs?: number;
+        coolOffPeriodMs?: number;
+        useAdaptiveSampling?: boolean;
+    }[];
+    amqp?: {
+        queue: string | '*';
+        samplingRate?: number;
+        maxResponseTimeMs?: number;
+        coolOffPeriodMs?: number;
+        useAdaptiveSampling?: boolean;
+    }[];
+    graphql?: {
+        gqlOpType: '*' | string;
+        selectionSet: string | '*';
+        samplingRate?: number;
+        maxResponseTimeMs?: number;
+        coolOffPeriodMs?: number;
+        useAdaptiveSampling?: boolean;
+    }[];
+    manualRequest?: {
+        name: string | '*';
+        samplingRate?: number;
+        maxResponseTimeMs?: number;
+        coolOffPeriodMs?: number;
+        useAdaptiveSampling?: boolean;
+    }[];
+};
+export declare let isAdaptiveSamplingUsed: boolean;
+export declare function setSamplingConfig(config: SamplingConfig): void;
+type CommonAdaptiveSamplingData = {
+    uniqueCoverageHashes: Set<string>;
+    totalRecordedRequests: number;
+};
+type HttpAdaptiveSamplingData = CommonAdaptiveSamplingData & {
+    pathParamsCount: number;
+    clusterPathRegex: RegExp;
+};
+type GrpcAdaptiveSamplingData = CommonAdaptiveSamplingData;
+type AmqpAdaptiveSamplingData = CommonAdaptiveSamplingData;
+type KafkaAdaptiveSamplingData = CommonAdaptiveSamplingData;
+type ManualAdaptiveSamplingData = CommonAdaptiveSamplingData;
+type GraphqlAdaptiveSamplingData = CommonAdaptiveSamplingData;
+type ReadableAdaptiveSamplingData = {
+    http: Record<string, Omit<HttpAdaptiveSamplingData, 'uniqueCoverageHashes'> & {
+        uniqueCoverageHashes: Array<string>;
+    }>;
+    grpc: Record<string, Omit<GrpcAdaptiveSamplingData, 'uniqueCoverageHashes'> & {
+        uniqueCoverageHashes: Array<string>;
+    }>;
+    amqp: Record<string, Omit<AmqpAdaptiveSamplingData, 'uniqueCoverageHashes'> & {
+        uniqueCoverageHashes: Array<string>;
+    }>;
+    kafka: Record<string, Omit<KafkaAdaptiveSamplingData, 'uniqueCoverageHashes' & {
+        uniqueCoverageHashes: Array<string>;
+    }>>;
+    manual: Record<string, Omit<ManualAdaptiveSamplingData, 'uniqueCoverageHashes'> & {
+        uniqueCoverageHashes: Array<string>;
+    }>;
+    graphql: Record<string, Omit<GraphqlAdaptiveSamplingData, 'uniqueCoverageHashes'> & {
+        uniqueCoverageHashes: Array<string>;
+    }>;
+};
+export declare function getAdaptiveSamplingState(): ReadableAdaptiveSamplingData;
+export declare function resetAdaptiveSampling(): void;
+export declare function setAdaptiveSamplingResetInterval({ intervalHrs, }: {
+    intervalHrs: number;
+}): void;
+export declare function considerHttpRequestForSampling(nonStandardRequestIdentifier: string, // `${apiVerb}_::_${clusterPath}`
+totalTimeElapsedMs: number, htRequestId: string): void;
+export declare function getHttpRequestSamplingMode(headers: IncomingHttpHeaders, incomingRequestMethod: HttpMethodEnum, incomingRequestPath: string): SamplingMode;
+export declare function considerGrpcRequestForSampling(requestIdentifier: string, totalTimeElapsedMs: number, htRequestId: string): void;
+export declare function getGrpcRequestSamplingMode(metadata: GrpcModule.Metadata, incomingRequestService: string, incomingRequestMethod: string): SamplingMode;
+export declare function considerKafkaRequestForSampling(requestIdentifier: string, totalTimeElapsedMs: number, htRequestId: string): void;
+export declare function getKafkaRequestSamplingMode(headers: KafkaJs.IHeaders, incomingRequestGroupId: string, incomingRequestTopic: string): SamplingMode;
+export declare function considerAmqpRequestForSampling(requestIdentifier: string, totalTimeElapsedMs: number, htRequestId: string): void;
+export declare function getAmqpRequestSamplingMode(headers: Amqp.MessagePropertyHeaders, incomingRequestQueue: string): SamplingMode;
+export declare function considerGraphqlRequestForSampling(requestIdentifier: string, totalTimeElapsedMs: number, htRequestId: string): void;
+export declare function getGraphqlRequestSamplingMode(headers: IncomingHttpHeaders, incomingRequestSelectionSet: string, incomingGqlOpType: string): SamplingMode;
+export declare function considerManualRequestForSampling(requestIdentifier: string, totalTimeElapsedMs: number, htRequestId: string): void;
+export declare function getManualRequestSamplingMode(incomingRequestName: string): SamplingMode;
+export {};

package/instrumentation/helpers/setBranchName.d.ts

@@ -0,0 +1,2 @@
+export declare const setBranchNameFromGit: () => string;
+export declare const getBranchName: () => string;

package/instrumentation/helpers/sqlParser.d.ts

@@ -0,0 +1,17 @@
+import type { AST, Parser } from 'node-sql-parser';
+import type { DangerouslyMakeJsonableMap } from '../../../../utils/types/jsonableTypes';
+export type HT_AST = DangerouslyMakeJsonableMap<AST> | {
+    type: 'begin|commit|rollback';
+} | {
+    type: 'unhandled';
+    rawSql: string;
+    value: string;
+};
+export declare class SqlParser {
+    private readonly parser;
+    private readonly dialect;
+    constructor(_Parser: typeof Parser, dialect: string);
+    getAst(sql: string): HT_AST | HT_AST[];
+    getAstSchema(ast: HT_AST | HT_AST[]): HT_AST | HT_AST[];
+    getSQLFromAST(ast: AST | AST[]): string;
+}

package/instrumentation/helpers/toJSONHandlers.d.ts

@@ -0,0 +1,7 @@
+export declare function evaluateToJSON(obj: unknown, depth?: number): unknown;
+export declare function deleteToJSONValues(obj: unknown, depth?: number): unknown;
+export declare function constructToJSONFunc(obj: unknown, ObjectIdClass: any, depth?: number): unknown;
+export declare function decodeObjectIds<T>(input: T, ObjectIdClass: any, depth?: number): T;
+export declare function encodeInputObjectIds<T>(input: T, ObjectIdClass: any, depth?: number): T;
+export declare function encodeOutputObjectIds<T>(input: T, ObjectIdClass: any, depth?: number): T;
+export declare function customToJSON(obj: any): any;

package/instrumentation/helpers/utils.d.ts

@@ -0,0 +1,10 @@
+import { type CoverageMapData, type FileCoverageData } from 'istanbul-lib-coverage';
+export declare function makeFirstLetterLower(str: string): string;
+export declare function remapCoverage(requestCoverage?: {
+    [filePathAbs: string]: {
+        [lineNumber: string]: number[];
+    };
+}): CoverageMapData;
+export declare function extractCoverageData(coverage: CoverageMapData): {
+    [filePathAbs: string]: FileCoverageData;
+};

package/instrumentation/index.d.ts

@@ -0,0 +1,4 @@
+import type { TracerProvider } from '@opentelemetry/api';
+import type { HtInstrumentationConfig } from './core/types';
+export declare const autoInstrumentation: (config?: HtInstrumentationConfig) => void;
+export declare const setHtTracerProvider: (tracerProvider: TracerProvider) => void;

package/instrumentation/libraries/amqplib/instrumentation.d.ts

@@ -0,0 +1,16 @@
+import type * as amqplib from 'amqplib';
+import type * as amqplibCallback from 'amqplib/callback_api';
+import type { Connection } from 'amqplib/lib/connection';
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtAmqplibInstrumentation extends HtInstrumentationBase {
+    connection: Connection;
+    channelCallback: amqplibCallback.Channel;
+    confirmChannelCallback: amqplibCallback.ConfirmChannel;
+    channelPromise: amqplib.Channel;
+    confirmChannelPromise: amqplib.ConfirmChannel;
+    constructor(options?: {
+        enabled: boolean;
+    });
+    protected init(): HtInstrumentationNodeModule<typeof amqplib>;
+}

package/instrumentation/libraries/amqplib/mocks/AckMock.d.ts

@@ -0,0 +1,3 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getChannelAckPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["ack"]) => (this: any, ...args: any[]) => any;

package/instrumentation/libraries/amqplib/mocks/AmqpConsumerMock.d.ts

@@ -0,0 +1,71 @@
+import type { ConsumeMessage } from 'amqplib/properties';
+import type { JsonSchemaWithoutLangType, JsonSchemaWithoutValues } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import { type ConsumeOptions, type MessageFields, type MessageProperties, OutputStatus } from '../../../../../../utils/types';
+import type { Jsonable } from '../../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtServerMockAbstract } from '../../../core/baseClasses/HtServerMockAbstract';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+type MsgHandler = (msg: ConsumeMessage | null) => Promise<void>;
+type EmptyObject = Record<string, never>;
+type ConsumerReadableInput = {
+    queue: string;
+    msg: {
+        content: string | Jsonable;
+        fields: MessageFields;
+        properties: MessageProperties;
+    };
+    messageType: HtAmqpMessageType;
+    options?: ConsumeOptions;
+};
+type InputMeta = {
+    contentBufferBase64?: string;
+};
+type ReadableInput = ConsumerReadableInput;
+type ProcessedInput = {
+    queue: string;
+    msg: {
+        content: string | Jsonable;
+    };
+    messageType: HtAmqpMessageType;
+};
+type ProcessedInputSchema = {
+    queue: string;
+    msg: {
+        content: Jsonable;
+    };
+    messageType: JsonSchemaWithoutValues;
+};
+type InputValueWithoutLangType = {
+    queue: string;
+    msg: {
+        content: JsonSchemaWithoutLangType;
+    };
+    messageType: JsonSchemaWithoutLangType;
+};
+type OutputValueWithoutLangType = null;
+type OutputMeta = EmptyObject;
+type RealOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+export declare class AmqpConsumerMock extends HtServerMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ProcessedOutputSchema, InputValueWithoutLangType, OutputValueWithoutLangType> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, packageName, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+    });
+    generateProcessedInput(): {
+        queue: string;
+        msg: {
+            content: Jsonable;
+        };
+        messageType: HtAmqpMessageType;
+    };
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateInputValueWithoutLangType(): InputValueWithoutLangType;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+    generateOutputValueWithoutLangType(): OutputValueWithoutLangType;
+    generateOutputStatus(): OutputStatus;
+    save(): void;
+}
+export declare function getConsumerMessagePatchFn(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], packageName: string, queue: string, consumeOptions: ConsumeOptions): (originalMsgHandler: MsgHandler) => (msg: ConsumeMessage) => Promise<any>;
+export {};

package/instrumentation/libraries/amqplib/mocks/AssertExchangeMock.d.ts

@@ -0,0 +1,4 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getCallbackModelAssertExchangePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["assertExchange"]) => (this: any, ...args: any[]) => any;
+export declare function getChannelModelAssertExchangePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["assertExchange"]) => (this: any, ...args: any[]) => Promise<unknown>;

package/instrumentation/libraries/amqplib/mocks/AssertQueueMock.d.ts

@@ -0,0 +1,4 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getCallbackModelAssertQueuePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["assertQueue"]) => (this: any, ...args: any[]) => any;
+export declare function getChannelModelAssertQueuePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["assertQueue"]) => (this: any, ...args: any[]) => Promise<unknown>;

package/instrumentation/libraries/amqplib/mocks/BindUnbindExchangeMock.d.ts

@@ -0,0 +1,6 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getCallbackModelBindExchangePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["bindExchange"]) => (this: any, ...args: any[]) => any;
+export declare function getChannelModelBindExchangePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["bindExchange"]) => (this: any, ...args: any[]) => Promise<unknown>;
+export declare function getCallbackModelUnbindExchangePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["unbindExchange"]) => (this: any, ...args: any[]) => any;
+export declare function getChannelModelUnbindExchangePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["unbindExchange"]) => (this: any, ...args: any[]) => Promise<unknown>;

package/instrumentation/libraries/amqplib/mocks/BindUnbindQueueMock.d.ts

@@ -0,0 +1,6 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getCallbackModelBindQueuePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["bindQueue"]) => (this: any, ...args: any[]) => any;
+export declare function getChannelModelBindQueuePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["bindQueue"]) => (this: any, ...args: any[]) => Promise<unknown>;
+export declare function getCallbackModelUnbindQueuePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["unbindQueue"]) => (this: any, ...args: any[]) => any;
+export declare function getChannelModelUnbindQueuePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["unbindQueue"]) => (this: any, ...args: any[]) => Promise<unknown>;

package/instrumentation/libraries/amqplib/mocks/CancelMock.d.ts

@@ -0,0 +1,4 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getCallbackModelCancelPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["cancel"]) => (this: any, ...args: any[]) => any;
+export declare function getChannelModelCancelPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["cancel"]) => (this: any, ...args: any[]) => Promise<unknown>;

package/instrumentation/libraries/amqplib/mocks/CheckExchangeMock.d.ts

@@ -0,0 +1,4 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getCallbackModelCheckExchangePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["checkExchange"]) => (this: any, ...args: any[]) => any;
+export declare function getChannelModelCheckExchangePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["checkExchange"]) => (this: any, ...args: any[]) => Promise<unknown>;

package/instrumentation/libraries/amqplib/mocks/CheckQueueMock.d.ts

@@ -0,0 +1,4 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getCallbackModelCheckQueuePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["checkQueue"]) => (this: any, ...args: any[]) => any;
+export declare function getChannelModelCheckQueuePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["checkQueue"]) => (this: any, ...args: any[]) => Promise<unknown>;

package/instrumentation/libraries/amqplib/mocks/ConsumeMock.d.ts

@@ -0,0 +1,4 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getCallbackModelConsumePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["consume"]) => (this: any, ...args: any[]) => any;
+export declare function getChannelModelConsumePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["consume"]) => (this: any, ...args: any[]) => Promise<unknown>;

package/instrumentation/libraries/amqplib/mocks/DeleteExchangeMock.d.ts

@@ -0,0 +1,4 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getCallbackModelDeleteExchangePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["deleteExchange"]) => (this: any, ...args: any[]) => any;
+export declare function getChannelModelDeleteExchangePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["deleteExchange"]) => (this: any, ...args: any[]) => Promise<unknown>;

package/instrumentation/libraries/amqplib/mocks/DeleteQueueMock.d.ts

@@ -0,0 +1,4 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getCallbackModelDeleteQueuePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["deleteQueue"]) => (this: any, ...args: any[]) => any;
+export declare function getChannelModelDeleteQueuePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["deleteQueue"]) => (this: any, ...args: any[]) => Promise<unknown>;

package/instrumentation/libraries/amqplib/mocks/EmptyMock.d.ts

@@ -0,0 +1,13 @@
+import type * as amqplib from 'amqplib';
+import type * as amqplibCallback from 'amqplib/callback_api';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getConnectPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: typeof amqplib.connect) => (this: any, ...args: any[]) => unknown;
+export declare function getCallbackModelCreateChannelPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string, isConfirmChannel: boolean): (originalFn: amqplibCallback.Connection["createChannel"] | amqplibCallback.Connection["createConfirmChannel"]) => (this: any, ...args: any[]) => unknown;
+export declare function getChannelModelCreateChannelPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string, isConfirmChannel: boolean): (originalFn: amqplib.Connection["createChannel"] | amqplib.Connection["createConfirmChannel"]) => (this: any, ...args: any[]) => Promise<any>;
+export declare function getCallbackModelClosePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplibCallback.Channel["close"]) => (this: any, ...args: any[]) => any;
+export declare function getChannelModelClosePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["close"]) => (this: any, ...args: any[]) => Promise<unknown>;
+export declare function getChannelAckAllPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["ackAll"]) => (this: any, ...args: any[]) => any;
+export declare function getConfirmChannelCallbackModelWaitForConfirmsPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.ConfirmChannel["waitForConfirms"]) => (this: any, ...args: any[]) => unknown;
+export declare function getConfirmChannelWaitForConfirmsPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.ConfirmChannel["waitForConfirms"]) => (this: any, ...args: any[]) => Promise<void> | Promise<any[]>;
+export declare function getCallbackModelRecoverPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplibCallback.Channel["recover"]) => (this: any, ...args: any[]) => unknown;
+export declare function getChannelModelRecoverPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["recover"]) => (this: any, ...args: any[]) => Promise<unknown>;

package/instrumentation/libraries/amqplib/mocks/GetMock.d.ts

@@ -0,0 +1,4 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getCallbackModelGetPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["get"]) => (this: any, ...args: any[]) => any;
+export declare function getChannelModelGetPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["get"]) => (this: any, ...args: any[]) => Promise<unknown>;

package/instrumentation/libraries/amqplib/mocks/NackAllMock.d.ts

@@ -0,0 +1,3 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getChannelNackAllPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["nackAll"]) => (this: any, ...args: any[]) => any;

package/instrumentation/libraries/amqplib/mocks/NackMock.d.ts

@@ -0,0 +1,51 @@
+import type * as amqplib from 'amqplib';
+import type { JsonSchemaWithoutValues } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import { FunctionTypeEnum } from '../../../../../../utils/types';
+import type { Jsonable } from '../../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+type EmptyObject = Record<string, never>;
+type NackInput = {
+    message: {
+        fields: Record<string, Jsonable>;
+        content: string | Jsonable;
+        properties: Record<string, Jsonable>;
+    };
+    messageType: HtAmqpMessageType;
+    allUpTo?: boolean;
+    requeue?: boolean;
+};
+type InputMeta = {
+    contentBufferBase64?: string;
+};
+type ReadableInput = NackInput;
+type ProcessedInput = NackInput;
+type ProcessedInputSchema = {
+    message: {
+        content: Jsonable;
+    };
+    messageType: JsonSchemaWithoutValues;
+    allUpTo?: JsonSchemaWithoutValues;
+    requeue?: JsonSchemaWithoutValues;
+};
+type OutputMeta = EmptyObject;
+type RealOutput = EmptyObject;
+type ReadableOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+export declare class NackMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, packageName, submoduleName, functionType, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): NackInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+    generateReadableOutput(): ReadableOutput;
+}
+export declare function getChannelNackPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["nack"]) => (this: any, ...args: any[]) => any;
+export {};

package/instrumentation/libraries/amqplib/mocks/PrefetchMock.d.ts

@@ -0,0 +1,4 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getCallbackModelPrefetchPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["publish"]) => (this: any, ...args: any[]) => any;
+export declare function getChannelModelPrefetchPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["prefetch"]) => (this: any, ...args: any[]) => Promise<unknown>;

package/instrumentation/libraries/amqplib/mocks/PublishMock.d.ts

@@ -0,0 +1,4 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getChannelPublishPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["publish"]) => (this: any, exchange: string, routingKey: string, content: Buffer, options?: amqplib.Options.Publish) => boolean;
+export declare function getConfirmChannelPublishPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.ConfirmChannel["publish"]) => (this: any, exchange: string, routingKey: string, content: Buffer, options?: amqplib.Options.Publish, callback?: (err: any, ok: amqplib.Replies.Empty) => void) => unknown;

package/instrumentation/libraries/amqplib/mocks/PurgeQueueMock.d.ts

@@ -0,0 +1,4 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getCallbackModelPurgeQueuePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["purgeQueue"]) => (this: any, ...args: any[]) => any;
+export declare function getChannelModelPurgeQueuePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["purgeQueue"]) => (this: any, ...args: any[]) => Promise<unknown>;

package/instrumentation/libraries/amqplib/mocks/RejectMock.d.ts

@@ -0,0 +1,3 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getChannelRejectPatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["reject"]) => (this: any, ...args: any[]) => any;

package/instrumentation/libraries/amqplib/mocks/SendToQueueMock.d.ts

@@ -0,0 +1,4 @@
+import type * as amqplib from 'amqplib';
+import type { HtAmqplibInstrumentation } from '../instrumentation';
+export declare function getChannelSendToQueuePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.Channel["sendToQueue"]) => (this: any, queue: string, content: Buffer, options?: amqplib.Options.Publish) => boolean;
+export declare function getConfirmChannelSendToQueuePatch(plugin: HtAmqplibInstrumentation, executeOriginalFnWithContext: HtAmqplibInstrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: amqplib.ConfirmChannel["sendToQueue"]) => (this: any, queue: string, content: Buffer, options?: amqplib.Options.Publish, callback?: (err: any, ok: amqplib.Replies.Empty) => void) => unknown;

package/instrumentation/libraries/amqplib/patchFnImports.d.ts

@@ -0,0 +1,71 @@
+import { getChannelAckPatch } from './mocks/AckMock';
+import { getCallbackModelAssertExchangePatch, getChannelModelAssertExchangePatch } from './mocks/AssertExchangeMock';
+import { getCallbackModelAssertQueuePatch, getChannelModelAssertQueuePatch } from './mocks/AssertQueueMock';
+import { getCallbackModelBindExchangePatch, getCallbackModelUnbindExchangePatch, getChannelModelBindExchangePatch, getChannelModelUnbindExchangePatch } from './mocks/BindUnbindExchangeMock';
+import { getCallbackModelBindQueuePatch, getCallbackModelUnbindQueuePatch, getChannelModelBindQueuePatch, getChannelModelUnbindQueuePatch } from './mocks/BindUnbindQueueMock';
+import { getCallbackModelCancelPatch, getChannelModelCancelPatch } from './mocks/CancelMock';
+import { getCallbackModelCheckExchangePatch, getChannelModelCheckExchangePatch } from './mocks/CheckExchangeMock';
+import { getCallbackModelCheckQueuePatch, getChannelModelCheckQueuePatch } from './mocks/CheckQueueMock';
+import { getCallbackModelConsumePatch, getChannelModelConsumePatch } from './mocks/ConsumeMock';
+import { getCallbackModelDeleteExchangePatch, getChannelModelDeleteExchangePatch } from './mocks/DeleteExchangeMock';
+import { getCallbackModelDeleteQueuePatch, getChannelModelDeleteQueuePatch } from './mocks/DeleteQueueMock';
+import { getCallbackModelClosePatch, getCallbackModelCreateChannelPatch, getCallbackModelRecoverPatch, getChannelAckAllPatch, getChannelModelClosePatch, getChannelModelCreateChannelPatch, getChannelModelRecoverPatch, getConfirmChannelCallbackModelWaitForConfirmsPatch, getConfirmChannelWaitForConfirmsPatch, getConnectPatch } from './mocks/EmptyMock';
+import { getCallbackModelGetPatch, getChannelModelGetPatch } from './mocks/GetMock';
+import { getChannelNackAllPatch } from './mocks/NackAllMock';
+import { getChannelNackPatch } from './mocks/NackMock';
+import { getCallbackModelPrefetchPatch, getChannelModelPrefetchPatch } from './mocks/PrefetchMock';
+import { getChannelPublishPatch, getConfirmChannelPublishPatch } from './mocks/PublishMock';
+import { getCallbackModelPurgeQueuePatch, getChannelModelPurgeQueuePatch } from './mocks/PurgeQueueMock';
+import { getChannelRejectPatch } from './mocks/RejectMock';
+import { getChannelSendToQueuePatch, getConfirmChannelSendToQueuePatch } from './mocks/SendToQueueMock';
+declare const _default: {
+    getConnectPatch: typeof getConnectPatch;
+    getCallbackModelCreateChannelPatch: typeof getCallbackModelCreateChannelPatch;
+    getChannelModelCreateChannelPatch: typeof getChannelModelCreateChannelPatch;
+    getCallbackModelClosePatch: typeof getCallbackModelClosePatch;
+    getChannelModelClosePatch: typeof getChannelModelClosePatch;
+    getCallbackModelAssertQueuePatch: typeof getCallbackModelAssertQueuePatch;
+    getChannelModelAssertQueuePatch: typeof getChannelModelAssertQueuePatch;
+    getCallbackModelCheckQueuePatch: typeof getCallbackModelCheckQueuePatch;
+    getChannelModelCheckQueuePatch: typeof getChannelModelCheckQueuePatch;
+    getCallbackModelDeleteQueuePatch: typeof getCallbackModelDeleteQueuePatch;
+    getChannelModelDeleteQueuePatch: typeof getChannelModelDeleteQueuePatch;
+    getCallbackModelPurgeQueuePatch: typeof getCallbackModelPurgeQueuePatch;
+    getChannelModelPurgeQueuePatch: typeof getChannelModelPurgeQueuePatch;
+    getCallbackModelPrefetchPatch: typeof getCallbackModelPrefetchPatch;
+    getChannelModelPrefetchPatch: typeof getChannelModelPrefetchPatch;
+    getCallbackModelBindQueuePatch: typeof getCallbackModelBindQueuePatch;
+    getChannelModelBindQueuePatch: typeof getChannelModelBindQueuePatch;
+    getCallbackModelUnbindQueuePatch: typeof getCallbackModelUnbindQueuePatch;
+    getChannelModelUnbindQueuePatch: typeof getChannelModelUnbindQueuePatch;
+    getCallbackModelAssertExchangePatch: typeof getCallbackModelAssertExchangePatch;
+    getChannelModelAssertExchangePatch: typeof getChannelModelAssertExchangePatch;
+    getCallbackModelCheckExchangePatch: typeof getCallbackModelCheckExchangePatch;
+    getChannelModelCheckExchangePatch: typeof getChannelModelCheckExchangePatch;
+    getCallbackModelDeleteExchangePatch: typeof getCallbackModelDeleteExchangePatch;
+    getChannelModelDeleteExchangePatch: typeof getChannelModelDeleteExchangePatch;
+    getCallbackModelBindExchangePatch: typeof getCallbackModelBindExchangePatch;
+    getChannelModelBindExchangePatch: typeof getChannelModelBindExchangePatch;
+    getCallbackModelUnbindExchangePatch: typeof getCallbackModelUnbindExchangePatch;
+    getChannelModelUnbindExchangePatch: typeof getChannelModelUnbindExchangePatch;
+    getCallbackModelRecoverPatch: typeof getCallbackModelRecoverPatch;
+    getChannelModelRecoverPatch: typeof getChannelModelRecoverPatch;
+    getChannelPublishPatch: typeof getChannelPublishPatch;
+    getConfirmChannelPublishPatch: typeof getConfirmChannelPublishPatch;
+    getChannelSendToQueuePatch: typeof getChannelSendToQueuePatch;
+    getConfirmChannelSendToQueuePatch: typeof getConfirmChannelSendToQueuePatch;
+    getConfirmChannelCallbackModelWaitForConfirmsPatch: typeof getConfirmChannelCallbackModelWaitForConfirmsPatch;
+    getConfirmChannelWaitForConfirmsPatch: typeof getConfirmChannelWaitForConfirmsPatch;
+    getCallbackModelConsumePatch: typeof getCallbackModelConsumePatch;
+    getChannelModelConsumePatch: typeof getChannelModelConsumePatch;
+    getCallbackModelCancelPatch: typeof getCallbackModelCancelPatch;
+    getChannelModelCancelPatch: typeof getChannelModelCancelPatch;
+    getCallbackModelGetPatch: typeof getCallbackModelGetPatch;
+    getChannelModelGetPatch: typeof getChannelModelGetPatch;
+    getChannelAckAllPatch: typeof getChannelAckAllPatch;
+    getChannelAckPatch: typeof getChannelAckPatch;
+    getChannelNackPatch: typeof getChannelNackPatch;
+    getChannelNackAllPatch: typeof getChannelNackAllPatch;
+    getChannelRejectPatch: typeof getChannelRejectPatch;
+};
+export default _default;

package/instrumentation/libraries/amqplib/replayModeHandlers.d.ts

@@ -0,0 +1,9 @@
+import type { ConsumeMessage } from 'amqplib/properties';
+import type { AmqpReqTypeMinimal } from '../../../../../utils/types';
+type Queue = string;
+type MsgHandler = (msg: ConsumeMessage | null) => Promise<void>;
+export declare function setPluginInstance(plugin: any): void;
+export declare const registerAmqpHandler: (handler: MsgHandler, queue: Queue) => void;
+export declare const getAmqpConsumer: (queue: Queue) => MsgHandler;
+export declare function runAmqpConsumer(handler: MsgHandler, amqpReqObjMinimal: AmqpReqTypeMinimal, requestId: string): Promise<void>;
+export {};

package/instrumentation/libraries/amqplib/utils.d.ts

@@ -0,0 +1,24 @@
+import type { CallbackModel } from 'amqplib/lib/callback_model.js';
+import type { ChannelModel } from 'amqplib/lib/channel_model.js';
+import type { Jsonable } from '../../../../../utils/types/jsonableTypes';
+export declare function modulesArray(moduleExports: ChannelModel | CallbackModel): {
+    module: any;
+    method: string;
+    subModuleName: string;
+}[];
+export declare function syncFunctionsArray(moduleExports: ChannelModel): {
+    module: any;
+    method: string;
+    subModuleName: string;
+}[];
+export declare const convertContentToBuffer: (content: string | Jsonable, contentBufferBase64: string, messageType: HtAmqpMessageType) => Buffer;
+export declare const bufferToStringAndMessageType: (content: Buffer) => {
+    content: any;
+    messageType: string;
+    contentBufferBase64: any;
+} | {
+    content: string;
+    messageType: string;
+    contentBufferBase64: string;
+};
+export declare function isRandomlyServerGenerated(name: string): boolean;

package/instrumentation/libraries/auth0/instrumentation.d.ts

@@ -0,0 +1,16 @@
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtAuth0Instrumentation extends HtInstrumentationBase {
+    _Original_AuthenticationClient: any;
+    _HT_Patched_AuthenticationClient: any;
+    _Original_ManagementClient: any;
+    _HT_Patched_ManagementClient: any;
+    constructor(options?: {
+        enabled: boolean;
+    });
+    protected init(): HtInstrumentationNodeModule<any>[];
+    private getExtendedAuthenticationClientClass;
+    private getPatchedAuthenticationClientClass;
+    private getExtendedManagementClientClass;
+    private getPatchedManagementClientClass;
+}