@hypertestco/node-sdk-v3 0.0.1-8

package/instrumentation/libraries/grpc/mocks/GrpcClientMock.d.ts

@@ -0,0 +1,42 @@
+import type { JsonSchema, JsonSchemaWithoutLangType, JsonSchemaWithoutValues } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { GrpcClientInputMeta as InputMeta, GrpcOutputMeta as OutputMeta, GrpcClientReadableInput as ReadableInput, GrpcClientRealOutput as RealOutput } from '../../../../../../utils/types/index';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+export type ProcessedInput = Omit<ReadableInput, 'metadata' | 'body'> & {
+    body: JsonSchema;
+};
+export type ProcessedInputSchema = {
+    body: JsonSchemaWithoutValues;
+    service: string;
+    method: string;
+};
+export type InputValueWithoutLangType = {
+    body: JsonSchemaWithoutLangType;
+    service: string;
+    method: string;
+};
+export type ReadableOutput = RealOutput;
+export type ProcessedOutputSchema = {
+    statusCode: number;
+    body: JsonSchemaWithoutValues;
+};
+export type OutputValueWithoutLangType = {
+    statusCode: number;
+    body: JsonSchemaWithoutLangType;
+};
+export declare const GRPC_CLIENT_REQUEST = "clientRequest";
+export declare class GrpcClientRequestMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema, InputValueWithoutLangType, OutputValueWithoutLangType> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, packageName, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateInputValueWithoutLangType(): InputValueWithoutLangType;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+    generateOutputValueWithoutLangType(): OutputValueWithoutLangType;
+    save(): void;
+}

package/instrumentation/libraries/grpc/mocks/GrpcServerMock.d.ts

@@ -0,0 +1,40 @@
+import type { JsonSchemaWithoutLangType, JsonSchemaWithoutValues } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import { OutputStatus } from '../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtServerMockAbstract } from '../../../core/baseClasses/HtServerMockAbstract';
+import type { GrpcClientInputMeta as InputMeta, GrpcOutputMeta as OutputMeta, GrpcServerReadableInput as ReadableInput, GrpcServerRealOutput as RealOutput } from '../../../../../../utils/types';
+type ProcessedInput = Omit<ReadableInput, 'metadata'>;
+export type ProcessedInputSchema = {
+    body: JsonSchemaWithoutValues;
+    service: string;
+    method: string;
+};
+export type InputValueWithoutLangType = {
+    body: JsonSchemaWithoutLangType;
+    service: string;
+    method: string;
+};
+export type ProcessedOutputSchema = {
+    statusCode: number;
+    body: JsonSchemaWithoutValues;
+    error: JsonSchemaWithoutValues;
+};
+type OutputValueWithoutLangType = {
+    statusCode: number;
+    body: JsonSchemaWithoutLangType;
+    error: JsonSchemaWithoutLangType;
+};
+export declare class GrpcServerRequestMock extends HtServerMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ProcessedOutputSchema, InputValueWithoutLangType, OutputValueWithoutLangType> {
+    constructor({ plugin, packageName, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateInputValueWithoutLangType(): InputValueWithoutLangType;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+    generateOutputValueWithoutLangType(): OutputValueWithoutLangType;
+    generateOutputStatus(realOutput: RealOutput): OutputStatus;
+    save(): void;
+}
+export {};

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

@@ -0,0 +1,8 @@
+import type * as GrpcModule from '@grpc/grpc-js';
+import type { GrpcReqTypeMinimal } from '../../../../../utils/types/index';
+type Path = string;
+export declare const registerGrpcHandler: (handler: GrpcModule.handleUnaryCall<unknown, unknown>, path: Path) => void;
+export declare const getGrpcHandler: (path: Path) => GrpcModule.handleUnaryCall<unknown, unknown> | undefined;
+export declare function setPluginInstance(plugin: any): void;
+export declare const runGrpcHandler: (handler: GrpcModule.handleUnaryCall<unknown, unknown>, grpcReqObjMinimal: GrpcReqTypeMinimal, requestId: string) => Promise<unknown>;
+export {};

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

@@ -0,0 +1,33 @@
+import type { Metadata } from '@grpc/grpc-js';
+import type { Metadata as MetadataOfDeprGrpc } from 'grpc';
+import type { BufferMap, GrpcClientInputMeta, GrpcClientReadableInput, GrpcReadableMetadata, GrpcServerInputMeta, GrpcServerReadableInput, JsonableStringMap } from '../../../../../utils/types/index';
+import { SamplingMode } from '../../helpers/samplingLogic';
+export declare const getReadableMetadata: (metadata: Metadata | undefined) => GrpcReadableMetadata;
+export declare const getReadableBodyAndBufferMap: (realBody: unknown) => {
+    readableBody: unknown;
+    bufferMap: BufferMap;
+    jsonableStringMap: JsonableStringMap;
+};
+export declare const extractServiceAndMethodFromPath: (path: string) => {
+    method: string;
+    service: string;
+};
+export declare const getReadableInputAndInputMetaForClient: (path: string, argument: unknown, metadata: Metadata) => {
+    readableInput: GrpcClientReadableInput;
+    inputMeta: GrpcClientInputMeta;
+};
+export declare const getReadableInputAndInputMetaForServer: (path: string, argument: unknown, metadata: Metadata) => {
+    readableInput: GrpcServerReadableInput;
+    inputMeta: GrpcServerInputMeta;
+};
+export declare const getRealMetadata: (MetadataConstructor: typeof Metadata, readableMetadata: GrpcReadableMetadata) => Metadata;
+export declare const getRealPayload: (readablePayload: unknown, bufferMap: BufferMap, jsonableStringMap: JsonableStringMap) => any;
+export declare const setSamplingModeHeaderInServerMetadata: (metadata: Metadata, samplingMode: SamplingMode) => void;
+export type ClassStore = {
+    Metadata: typeof Metadata;
+    MetadataOfDeprGrpc: typeof MetadataOfDeprGrpc;
+};
+declare const classStore: Map<string, Partial<ClassStore>>;
+export declare function insertInClassStore(version: string, classStoreObj: Partial<ClassStore>): void;
+export declare function getFromClassStore<T extends keyof ClassStore>(version: string, className: T): ClassStore[T];
+export { classStore };

package/instrumentation/libraries/http/HtHttpMockSocket.d.ts

@@ -0,0 +1,51 @@
+import EventEmitter from 'events';
+export declare class HtHttpMockSocket extends EventEmitter {
+    authorized: boolean;
+    _hadError: boolean;
+    connecting: boolean;
+    private readonly writableLength;
+    private readonly bufferSize;
+    private writable;
+    private readable;
+    private readonly pending;
+    private destroyed;
+    private readonly encrypted;
+    private timeout;
+    private readonly localAddress;
+    private readonly remoteFamily;
+    private readonly localPort;
+    private readonly remoteAddress;
+    private readonly remotePort;
+    private readableEnded;
+    private writableFinished;
+    constructor(options: any);
+    setNoDelay(): this;
+    setKeepAlive(): this;
+    resume(): this;
+    ref(): this;
+    unref(): this;
+    write(): boolean;
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    };
+    setTimeout(timeoutMs: any, fn?: any): this;
+    /**
+     * Artificial delay that will trip socket timeouts when appropriate.
+     *
+     * Doesn't actually wait for time to pass.
+     * Timeout events don't necessarily end the request.
+     * While many clients choose to abort the request upon a timeout, Node itself does not.
+     */
+    applyDelay(delayMs: any): void;
+    getPeerCertificate(): string;
+    /**
+     * Denotes that no more I/O activity should happen on this socket.
+     *
+     * The implementation in Node if far more complex as it juggles underlying async streams.
+     * For the purposes of Nock, we just need it to set some flags and on the first call
+     * emit a 'close' and optional 'error' event. Both events propagate through the request object.
+     */
+    destroy(err: any): this;
+}

package/instrumentation/libraries/http/HtMockClientRequest.d.ts

@@ -0,0 +1,28 @@
+import { ClientRequest, IncomingMessage } from 'http';
+import { HtHttpMockSocket } from './HtHttpMockSocket';
+export interface HtMockClientRequest extends ClientRequest {
+}
+export declare class HtMockClientRequest {
+    options: Record<string, unknown> & {
+        headers: Record<string, string>;
+    };
+    readonly socket: HtHttpMockSocket;
+    readonly response: IncomingMessage;
+    playbackStarted: boolean;
+    readyToStartPlaybackOnSocketEvent: boolean;
+    connection: HtHttpMockSocket;
+    res: IncomingMessage;
+    path: string;
+    method: string;
+    readonly requestBodyBuffers: Buffer[];
+    constructor(...args: any[]);
+    attachReq(): void;
+    socketOnClose(): void;
+    connectSocket(): Promise<void>;
+    maybeStartPlayback(): Promise<void>;
+    write(...args: any[]): boolean;
+    end(...args: unknown[]): ClientRequest;
+    flushHeaders(): void;
+    startPlayback(): Promise<void>;
+    play(statusCode: any, body: any, headers: any): void;
+}

package/instrumentation/libraries/http/helpers/decodeBody.d.ts

@@ -0,0 +1 @@
+export declare const decodeBody: (buffer: Buffer, encoding: string) => Promise<Buffer>;

package/instrumentation/libraries/http/helpers/eventPropagator.d.ts

@@ -0,0 +1,3 @@
+export declare function propagate(events: any, source: any, dest: any): {
+    end(): void;
+};

package/instrumentation/libraries/http/helpers/getClusterPathForClientReqDuringReplay.d.ts

@@ -0,0 +1,7 @@
+import type { HttpMethodEnum } from '../../../../../../utils/types';
+export declare const getClusterPathForClientReqDuringReplay: ({ instrumentationName, submoduleName, method, path, }: {
+    instrumentationName: string;
+    submoduleName: string;
+    method: HttpMethodEnum;
+    path: string;
+}) => string;

package/instrumentation/libraries/http/helpers/htHttpBodyParser.d.ts

@@ -0,0 +1,34 @@
+export declare const debug: import("debug").Debugger;
+export type FileMetaData = {
+    key: string;
+    filename: string;
+    encoding: string;
+    mimeType: string;
+    htFileEncoding: 'utf-8' | 'base64';
+    fileBodyArrayIndex: number;
+};
+export type FieldData = {
+    key: string;
+    value: string;
+    encoding: string;
+    mimeType: string;
+};
+export type MultipartData = {
+    fields: FieldData[];
+    filesMetaData: FileMetaData[];
+    filesBodyArr: string[];
+};
+export type HtParsedBody = {
+    bodyType: HtHttpBodyType;
+    jsonBody: object | string | undefined;
+    rawBody: string;
+    rawBodyEncoding: HtRawEncoding;
+    multipartFiles: string[];
+    bodyParsingError: boolean;
+};
+export type HtHttpJsonMultiPartBody = {
+    fields: FieldData[];
+    filesMetaData: FileMetaData[];
+};
+export declare const htHttpBodyParserSync: (bodyBuffer: Buffer, contentType: any) => HtParsedBody;
+export declare const htHttpBodyParser: (bodyBuffer: Buffer, contentType: string | string[]) => Promise<HtParsedBody>;

package/instrumentation/libraries/http/helpers/processedInputOutputSchemaHelper.d.ts

@@ -0,0 +1,5 @@
+import type { InputValueWithoutLangType, OutputValueWithoutLangType, ProcessedInput, ProcessedInputSchema, ProcessedOutputSchema, RealOutput } from '../mocks/HttpServerRequestMock';
+export declare const generateProcessedInputSchema: (processedInput: ProcessedInput) => ProcessedInputSchema;
+export declare const generateInputValueWithoutLangType: (processedInput: ProcessedInput) => InputValueWithoutLangType;
+export declare const generateProcessedOutputSchema: (realOutput: RealOutput) => ProcessedOutputSchema;
+export declare const generateOutputValueWithoutLangType: (realOutput: RealOutput) => OutputValueWithoutLangType;

package/instrumentation/libraries/http/httpHooks.d.ts

@@ -0,0 +1,59 @@
+import { type ClientRequest, IncomingMessage, type ServerResponse } from 'http';
+import urlLib from 'url';
+import { type HttpMeta, HttpMethodEnum, type HttpReqTypeWithoutBody } from '../../../../../utils/types';
+import type { HttpClientRequestMock } from './mocks/HttpClientRequestMock';
+import type { HttpServerRequestMock } from './mocks/HttpServerRequestMock';
+export declare const parseHeaders: (headers: Record<string, string | string[] | number>) => Record<string, string>;
+export declare function getHeadersFromFetchRequestOrResponse(headers: Headers | Record<string, string> | [string, string][]): {};
+export declare const parseAndStoreFetchHttpRequest: ({ headers, parsedUrl, clusterPath, clonedRequestObj, mock, }: {
+    headers: Record<string, string>;
+    parsedUrl: urlLib.UrlWithStringQuery;
+    clusterPath: string;
+    clonedRequestObj: Request;
+    mock: HttpClientRequestMock;
+}) => Promise<HttpReqTypeWithoutBody>;
+export declare const parseAndStoreFetchHttpResponse: ({ clonedResponseObj, mock, readableInput, }: {
+    clonedResponseObj: Response;
+    mock: HttpClientRequestMock;
+    readableInput: HttpReqTypeWithoutBody;
+}) => Promise<void>;
+export declare const parseAndSetFetchClientRequestRecordMode: ({ htHttReqWithoutBody, bodyBuffer, }: {
+    htHttReqWithoutBody: HttpReqTypeWithoutBody;
+    bodyBuffer: Buffer;
+}) => Promise<{
+    bodyType: HtHttpBodyType;
+    jsonBody: string | object;
+    hasBodyParsingError: boolean;
+    httpMeta: HttpMeta;
+    method: HttpMethodEnum;
+    clusterPath: string;
+    query: Record<string, string>;
+    headers: Record<string, string>;
+    path: string;
+    host: string;
+}>;
+export declare const parseAndSetFetchClientResponseRecordMode: ({ res, readableInput, mock, bodyBuffer, }: {
+    res: Response;
+    readableInput: HttpReqTypeWithoutBody;
+    mock: HttpClientRequestMock;
+    bodyBuffer: Buffer;
+}) => Promise<void>;
+export declare const constructFetchResponseObjReplayMode: ({ output, outputMeta, }: {
+    output: any;
+    outputMeta: any;
+}) => Response;
+export declare const addHeaderToFetchRequest: ({ input, init, value, header, }: {
+    input: RequestInfo | URL;
+    init?: RequestInit;
+    value: string;
+    header: string;
+}) => {
+    input: RequestInfo | URL;
+    init: RequestInit;
+};
+export declare const httpServerRequestHookRecordMode: (req: IncomingMessage, mock: HttpServerRequestMock) => void;
+export declare const httpServerResponseHookRecordMode: (res: ServerResponse, mock: HttpServerRequestMock) => void;
+export declare const httpClientRequestHookRecordMode: (req: ClientRequest, _mock: HttpClientRequestMock) => void;
+export declare const httpClientResponseHookRecordMode: (req: ClientRequest, res: IncomingMessage, mock: HttpClientRequestMock) => void;
+export declare const httpClientRequestErrHookRecordMode: (req: ClientRequest, err: Error, mock: HttpClientRequestMock) => void;
+export declare const httpServerResponseHookReplayMode: (res: ServerResponse, req: IncomingMessage, mock: HttpServerRequestMock) => void;

package/instrumentation/libraries/http/instrumentation.d.ts

@@ -0,0 +1,24 @@
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+import type * as HttpModule from 'http';
+import type * as HttpsModule from 'https';
+export declare class HtHttpInstrumentation extends HtInstrumentationBase {
+    htHttpRequestFn: any;
+    htHttpsRequestFn: any;
+    HtClientRequest: any;
+    ignoredHostsForHttpReqs: Array<string | RegExp>;
+    constructor(options?: {
+        enabled: boolean;
+        ignoredHostsForHttpReqs?: Array<string | RegExp>;
+    });
+    protected init(): (HtInstrumentationNodeModule<typeof HttpModule> | HtInstrumentationNodeModule<typeof HttpsModule> | (NodeJS.Global & typeof globalThis))[];
+    private _fetchWrapper;
+    private _getHttpInstrumentation;
+    private _getHttpsInstrumentation;
+    private unpatchHttpModule;
+    private getClientRequestClassPatchFn;
+    private getIncomingHttpRequestPatchFn;
+    private getOutgoingHttpRequestPatchFn;
+    private getOutgoingHttpsRequestPatchFn;
+    private getOutgoingGetPatchFn;
+}

package/instrumentation/libraries/http/mocks/HttpClientRequestMock.d.ts

@@ -0,0 +1,19 @@
+import { type HttpResType } from '../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { InputMeta, InputValueWithoutLangType, OutputMeta, OutputValueWithoutLangType, ProcessedInput, ProcessedInputSchema, ProcessedOutputSchema, ReadableInput, ReadableOutput, RealOutput } from './HttpServerRequestMock';
+export declare class HttpClientRequestMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema, InputValueWithoutLangType, OutputValueWithoutLangType> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, packageName, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateInputValueWithoutLangType(): InputValueWithoutLangType;
+    generateReadableOutput(realOutput: HttpResType): HttpResType;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+    generateOutputValueWithoutLangType(): OutputValueWithoutLangType;
+    save(): void;
+}

package/instrumentation/libraries/http/mocks/HttpServerRequestMock.d.ts

@@ -0,0 +1,47 @@
+import { type HttpMeta, type HttpReqType, type HttpReqTypeWithoutClusterPath, type HttpResType, OutputStatus } from '../../../../../../utils/types';
+import type { JsonSchemaWithoutLangType, JsonSchemaWithoutValues } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import type { JsonableMap } from '../../../../../../utils/types/jsonableTypes';
+import { HtServerMockAbstract } from '../../../core/baseClasses/HtServerMockAbstract';
+export declare class HttpServerRequestMock extends HtServerMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ProcessedOutputSchema, InputValueWithoutLangType, OutputValueWithoutLangType> {
+    _readableInput?: HttpReqTypeWithoutClusterPath;
+    _inputMeta?: HttpMeta;
+    _parentHtRequestId?: string;
+    _realOutput?: RealOutput;
+    _outputMeta?: HttpMeta;
+    constructor({ plugin, packageName, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+    });
+    setReadableInput(readableInput: HttpReqTypeWithoutClusterPath, inputMeta: HttpMeta, parentHtRequestId?: string): void;
+    setRealOutput(realOutput: RealOutput, outputMeta: HttpMeta): void;
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateInputValueWithoutLangType(): InputValueWithoutLangType;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+    generateOutputValueWithoutLangType(): OutputValueWithoutLangType;
+    generateOutputStatus(realOutput: RealOutput): OutputStatus;
+    save(): void;
+}
+export type QuerySchema = Record<string, 'y'>;
+export type ReadableInput = HttpReqType;
+export type ProcessedInput = Pick<ReadableInput, 'method' | 'clusterPath' | 'query' | 'jsonBody' | 'bodyType' | 'hasBodyParsingError'>;
+export type ProcessedInputSchema = Omit<ProcessedInput, 'jsonBody' | 'query'> & {
+    jsonBodySchema: JsonSchemaWithoutValues;
+    querySchema: QuerySchema;
+};
+export type InputValueWithoutLangType = Omit<ProcessedInput, 'jsonBody' | 'query'> & {
+    jsonBodySchema: JsonSchemaWithoutLangType;
+    querySchema: Record<string, string>;
+};
+export type InputMeta = HttpMeta;
+export type RealOutput = Omit<HttpResType, 'outputStatus'>;
+export type ReadableOutput = RealOutput;
+export type ProcessedOutputSchema = Omit<ReadableOutput, 'headers' | 'jsonBody'> & {
+    jsonBodySchema: JsonSchemaWithoutValues;
+};
+export type OutputValueWithoutLangType = Omit<ReadableOutput, 'headers' | 'jsonBody'> & {
+    jsonBodySchema: JsonSchemaWithoutLangType;
+};
+export type OutputMeta = HttpMeta;
+export type UserMeta = JsonableMap;

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

@@ -0,0 +1,52 @@
+import type * as HttpModule from 'http';
+import type * as HttpsModule from 'https';
+import { URL } from 'url';
+import { HTTP_PARENT_REQUEST_HEADER, HT_GRAPHQL_OP_ID, HT_REQUEST_ID, IS_ROOT_TRACE_KEY } from '../../core/helpers/utils';
+import { SamplingMode } from '../../helpers/samplingLogic';
+type ClientRequest = HttpModule.ClientRequest;
+type IncomingMessage = HttpModule.IncomingMessage;
+export { HT_REQUEST_ID, IS_ROOT_TRACE_KEY, HT_GRAPHQL_OP_ID, HTTP_PARENT_REQUEST_HEADER, };
+export declare const setDefaultOptions: (options: HttpsModule.RequestOptions) => void;
+export declare const isValidOptionsType: (options: unknown) => boolean;
+export declare const getRequestPathname: (options: URL | HttpModule.RequestOptions | string) => string;
+export declare const shouldFilterRequest: (headers?: Record<string, string>, hostname?: string) => boolean;
+/**
+ * Converts the arguments from the various signatures of http[s].request into a standard
+ * options object and an optional callback function.
+ *
+ * https://nodejs.org/api/http.html#http_http_request_url_options_callback
+ *
+ * Taken from the beginning of the native `ClientRequest`.
+ * https://github.com/nodejs/node/blob/908292cf1f551c614a733d858528ffb13fb3a524/lib/_http_client.js#L68
+ */
+export declare function normalizeClientRequestArgs(input: any, options: any, cb: any): {
+    options: any;
+    callback: any;
+};
+/**
+ * Return a new object with all field names of the headers lower-cased.
+ *
+ * Duplicates throw an error.
+ */
+export declare function headersFieldNamesToLowerCase(headers: any, throwOnDuplicate: any): {};
+export declare function isRequestDestroyed(req: ClientRequest): boolean;
+export declare function headersInputToRawArray(headers: any): any[];
+export declare function convertBodyToStream(body: any): any;
+export declare function getInputForHttpReqType(options: Record<string, string>): {
+    host: string;
+    path: string;
+    query: any;
+};
+export declare function extractHost(obj: {
+    headers?: {
+        host: string;
+        port?: string;
+    };
+    hostname?: string;
+    host?: string;
+    port?: string;
+}): string | null;
+export declare const isHtSdkReqFn: (req: IncomingMessage) => boolean;
+export declare const isHtSdkGraphqlReqFn: (req: IncomingMessage) => boolean;
+export declare const getIncomingResponseHeader: (res: IncomingMessage, headerName: any) => string | undefined;
+export declare const setSamplingModeHeaderInServerResponse: (response: HttpModule.ServerResponse, samplingMode: SamplingMode) => void;

package/instrumentation/libraries/ioredis/instrumentation.d.ts

@@ -0,0 +1,11 @@
+import type IoredisTypes from 'ioredis';
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtIoredisInstrumentation extends HtInstrumentationBase {
+    _Original_IoredisClass: typeof IoredisTypes | undefined;
+    constructor(options?: {
+        enabled: boolean;
+    });
+    protected init(): HtInstrumentationNodeModule<unknown>[];
+    private getPatchedIoredisClientClass;
+}

package/instrumentation/libraries/ioredis/mocks/IORedisClusterMock.d.ts

@@ -0,0 +1,42 @@
+import { type AnyFunction, FunctionTypeEnum } from '../../../../../../utils/types';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { JsonSchema, JsonSchemaWithoutValues } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { Jsonable } from '../../../../../../utils/types/jsonableTypes';
+import type { HtIoredisInstrumentation } from '../instrumentation';
+type InputMeta = Record<number, {
+    bufferMeta?: string;
+    encoding: HtRawEncoding;
+    isValueJson?: boolean;
+}>;
+type ReadableInput = {
+    functionArgs: Record<number, Jsonable>;
+};
+type ProcessedInput = JsonSchema;
+type ProcessedInputSchema = JsonSchemaWithoutValues;
+type OutputMeta = {
+    value?: string;
+    encoding?: HtRawEncoding;
+    isValueJson?: boolean;
+};
+type RealOutput = {
+    returnValue: Jsonable;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class IORedisClusterMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, isImportantMock, }: {
+        plugin: HtIoredisInstrumentation;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+        isImportantMock: boolean;
+    });
+    generateProcessedInput(): JsonSchema;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+}
+export declare function getPatchedClusterConnect(plugin: HtIoredisInstrumentation, executeOriginalFnWithContext: HtIoredisInstrumentation['executeOriginalFnWithContext'], submoduleName: string): (original: AnyFunction) => (this: unknown, ...args: unknown[]) => Promise<unknown>;
+export declare function getPatchRedisClusterSendCommand(plugin: HtIoredisInstrumentation, executeOriginalFnWithContext: HtIoredisInstrumentation['executeOriginalFnWithContext'], submoduleName: string): (originalFn: AnyFunction) => (this: unknown, ...args: unknown[]) => Promise<Jsonable> | Promise<string | Buffer>;
+export {};

package/instrumentation/libraries/ioredis/mocks/IORedisMock.d.ts

@@ -0,0 +1,42 @@
+import { type AnyFunction, FunctionTypeEnum } from '../../../../../../utils/types';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { JsonSchema, JsonSchemaWithoutValues } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { Jsonable } from '../../../../../../utils/types/jsonableTypes';
+import type { HtIoredisInstrumentation } from '../instrumentation';
+type InputMeta = Record<number, {
+    bufferMeta?: string;
+    encoding: HtRawEncoding;
+    isValueJson?: boolean;
+}>;
+type ReadableInput = {
+    functionArgs: Record<number, Jsonable>;
+};
+type ProcessedInput = JsonSchema;
+type ProcessedInputSchema = JsonSchemaWithoutValues;
+type OutputMeta = {
+    value?: string;
+    encoding?: HtRawEncoding;
+    isValueJson?: boolean;
+};
+type RealOutput = {
+    returnValue: Jsonable;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class IORedisMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, isImportantMock, }: {
+        plugin: HtIoredisInstrumentation;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+        isImportantMock: boolean;
+    });
+    generateProcessedInput(): JsonSchema;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+}
+export declare function getPatchedClientConnect(plugin: HtIoredisInstrumentation, executeOriginalFnWithContext: HtIoredisInstrumentation['executeOriginalFnWithContext'], submoduleName: string): (original: AnyFunction) => (this: unknown, ...args: unknown[]) => Promise<unknown>;
+export declare function getPatchRedisClientSendCommand(plugin: HtIoredisInstrumentation, executeOriginalFnWithContext: HtIoredisInstrumentation['executeOriginalFnWithContext'], submoduleName: string): (original: AnyFunction) => (this: unknown, ...args: unknown[]) => Promise<Jsonable> | Promise<string | Buffer>;
+export {};

package/instrumentation/libraries/ioredis/mocks/IORedisPipelineExecMock.d.ts

@@ -0,0 +1,43 @@
+import type { Pipeline } from 'ioredis';
+import { FunctionTypeEnum } from '../../../../../../utils/types';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { JsonSchemaWithoutValues } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { Jsonable } from '../../../../../../utils/types/jsonableTypes';
+import type { HtIoredisInstrumentation } from '../instrumentation';
+type InputMeta = Record<number, {
+    bufferMeta?: string;
+    encoding: HtRawEncoding;
+    isValueJson?: boolean;
+}>;
+type ReadableInput = {
+    functionArgs: Record<number, {
+        command: string;
+        args: string[];
+    }>;
+};
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = JsonSchemaWithoutValues;
+type OutputMeta = {
+    returnType?: string;
+};
+type RealOutput = {
+    returnValue: Jsonable;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class IORedisPipelineExecMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, isImportantMock, }: {
+        plugin: HtIoredisInstrumentation;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+        isImportantMock: boolean;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+}
+export declare function getPatchPipelineExec(plugin: HtIoredisInstrumentation, executeOriginalFnWithContext: HtIoredisInstrumentation['executeOriginalFnWithContext']): (original: (...args: unknown[]) => unknown) => (this: Pipeline, ...args: unknown[]) => unknown;
+export {};

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

@@ -0,0 +1,11 @@
+import { getPatchRedisClusterSendCommand, getPatchedClusterConnect } from './mocks/IORedisClusterMock';
+import { getPatchRedisClientSendCommand, getPatchedClientConnect } from './mocks/IORedisMock';
+import { getPatchPipelineExec } from './mocks/IORedisPipelineExecMock';
+declare const _default: {
+    getPatchedClientConnect: typeof getPatchedClientConnect;
+    getPatchRedisClientSendCommand: typeof getPatchRedisClientSendCommand;
+    getPatchedClusterConnect: typeof getPatchedClusterConnect;
+    getPatchRedisClusterSendCommand: typeof getPatchRedisClusterSendCommand;
+    getPatchPipelineExec: typeof getPatchPipelineExec;
+};
+export default _default;

package/instrumentation/libraries/jsonwebtoken/instrumentation.d.ts

@@ -0,0 +1,13 @@
+import type * as JsonwebtokenTypes from '@types/jsonwebtoken';
+import type { AnyFunction } from '../../../../../utils/types';
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtJsonWebTokenInstrumentation extends HtInstrumentationBase {
+    _OriginalJwtDecodeFn: AnyFunction;
+    _JsonWebTokenError: any;
+    _NotBeforeError: any;
+    _TokenExpiredError: any;
+    constructor(config?: {});
+    protected init(): HtInstrumentationNodeModule<typeof JsonwebtokenTypes>[];
+    private getVerifyPatch;
+}