@hypertestco/node-sdk-v3 0.0.1-8

package/instrumentation/core/helpers/memoryStore.d.ts

@@ -0,0 +1,345 @@
+import type { Span } from 'opentelemetry-api';
+import type { AmqpRequestReplayResult, AnyFunction, GRPCRequestReplayResult, GraphqlMetaMap, GraphqlRequestReplayResult, HTTPRequestReplayResult, HtMockMemoryMap, HtReplayMockObj, KafkaRequestReplayResult, ManualRequestReplayResult, ReplayMockSchemaMap, RootTagType, SpanId, SpansChecksumArray, TerminatedSpansArr } from '../../../../../utils/types';
+import type { SamplingMode } from '../../helpers/samplingLogic';
+import type { GraphqlServerRequestMock } from '../../../instrumentation/libraries/graphql/mocks/GraphqlServerRequestMock';
+import type { JsonableMap } from '../../../../../utils/types/jsonableTypes';
+import type { ExperimentalFlags } from '../types/ExperimentalFlagEnums';
+type HtRequestId = string;
+type RouteObject = {
+    endpointPath: string;
+    routerFn: AnyFunction;
+};
+type SpanInfo = {
+    spanId: string;
+    inputValueHash: string;
+    outputValueHash: string;
+    instrumentationName: string;
+    submoduleName: string;
+};
+export default class MemoryStore {
+    private static instance;
+    /**
+     * Maps current otel trace id to current ht trace id
+     * */
+    private readonly traceIdMap;
+    /**
+     * Stores root mocks
+     * */
+    private readonly rootMockMap;
+    private rootMockUpdated;
+    /**
+     * Maps root mocks to its replayed mocks
+     */
+    private readonly rootReplayMockMap;
+    /**
+     * Maps request id to its mocks
+     * */
+    private readonly requestMockMap;
+    /**
+     * Maps trace id to its replayed mocks
+     * */
+    private readonly requestReplayMockMap;
+    /**
+     * Maps http request id to its result schemas(response, replay mocks)
+     * */
+    private readonly httpRequestReplayResultMap;
+    /**
+     * Maps manual request id to its result schemas(response, replay mocks)
+     * */
+    private readonly manualRequestReplayResultMap;
+    /**
+     * Maps graphql request id to its result schemas(response, replay mocks)
+     * */
+    private readonly graphqlRequestReplayResultMap;
+    /**
+     * Maps request id to its result schemas for kafka requests (replay mocks) // We don't store response schema for kafka requests
+     **/
+    private readonly kafkaRequestReplayResultMap;
+    /**
+     * Maps request id to its result schemas for grpc requests (replay mocks)
+     **/
+    private readonly grpcRequestReplayResultMap;
+    /**
+     * Maps request id to its result schemas for amqp requests (replay mocks) // We don't store response schema for amqp requests
+     **/
+    private readonly amqpRequestReplayResultMap;
+    /**
+     * Maps request id to its associated spansChecksumArr(Array<spanId>)
+     * */
+    private readonly spansChecksumArrMap;
+    /**
+     * Maps request id to its associated spans({ spanId: ClientMock })
+     * */
+    private readonly spanMetadataMap;
+    /**
+     * Maps request id to its associated terminatedSpansArr(Array<spanId>)
+     * */
+    private readonly terminatedSpansArrMap;
+    /**
+     * This is to propagate a htRequestId for one selection set in a graphql request
+     * This is done to handle namespacing
+     * */
+    private readonly graphqlNamespaceMap;
+    /**
+     * This is to store all the selection set Requests to use in execute patch to create
+     * graphql requests with the same request id for each selection set
+     * */
+    private readonly selectionSetRequestIds;
+    private readonly debug;
+    /**
+     * Set of all HT_REQUEST_IDS whose server spans needs to be deleted as they are part of some other mockType
+     */
+    private readonly discardedHtRequestIds;
+    private appHealthStatus;
+    /**
+     * Flag to notify that the server is apollo graphql based and http headers should be saved against htRequestId in memory store
+     * for graphql instrumentation use and later cleared
+     */
+    private isGraphqlServer;
+    /**
+     * User will provide us known cluster paths from the functions exposed by the SDK
+     * This is usefull for better clustering of outbound calls and deduplication
+     *
+     * Cluster paths from downstream service's response headers precedes these
+     */
+    private userDefinedClusterPaths;
+    /**
+     * User will provide us known cluster paths from the functions exposed by the SDK
+     * This is usefull for better clustering of outbound calls and deduplication
+     *
+     * These are prioritized over cluster paths from downstream service's response headers
+     */
+    private highPriorityUserClusterPaths;
+    /**
+     * Map to store http based graphql req headers
+     */
+    private readonly graphqlRequestHeaders;
+    /**
+     * Map to store graphql defintion for a operation
+     */
+    private readonly graphqlDefinition;
+    /** Map to store clusterPath  for a request */
+    private readonly clusterPathMap;
+    /** Map to temporarily store clusterPaths against requestId */
+    private readonly tempReqClusterPathMap;
+    /**
+     * Map to temporarily store graphql server mock against its htRequestId.
+     * This needs to be done as its creation happens in resolver patch and readableInput attachment happens in execute patch
+     * **/
+    private readonly graphqlServerMockMap;
+    /**
+     * This is a list of root tags created on boot
+     */
+    private rootTags;
+    /**
+     *  This is a list of unique tags created for a particular requestId
+     */
+    private htRequestIdTags;
+    /**
+      This is a map of request ids vs their respective serverSpanStartTimestamp( as a ISO string )
+     */
+    private serverSpanStartTimestampMap;
+    private selectionSetMap;
+    /**
+     * This is a map to store http server context client instrumentation mocks for a graphql request
+     */
+    private httpServerCtxInstrumentationSpans;
+    private codeCoverageMap;
+    /**
+     * This is a map of htRequestId to the current value of the execution counter for the code coverage
+     */
+    private htRequestIdExecutionCounterMap;
+    private experimentalFlagMap;
+    /**
+     * List of libraries to ignore while initialising hypertest sdk
+     */
+    private libsToIgnoreWhileHtSdkInitialise;
+    /**
+     * This is a set to store patched initialised function to track if original function is invoked
+     * If patch results in an error then we call the original function to handle instrumentation exception in record mode.
+     * We collect data of error and send it to posthog to fix the issue.
+     */
+    private patchedFnInvokeStatusHash;
+    private gqlSelectionSetSamplingModeMap;
+    private uniqueSpanValueHashMap;
+    private repeatedSpanValueHashMap;
+    /**
+      This is a map of request ids vs their respective userMeta, (that the user created during record)
+    */
+    private userMetaMap;
+    /**
+     * This is a map of global discarded spans which will be filtered out in the trace exporter to reduce load on logger
+     */
+    private discardedSpansMap;
+    /**
+     * This is map of htRequestId as key to the value being the identifiers of manual mock v2 to avoid mocks
+     */
+    private uniqueManualMockV2IdsOfCurrentReq;
+    /**
+     * This is map of htRequestId as key to the value being the properties of kv mock to avoid duplicates
+     */
+    private uniqueKvMockPropsOfCurrentReq;
+    private constructor();
+    static getInstance(): MemoryStore;
+    isKvMockAlreadyRecorded(htRequestId: string, property: string): boolean;
+    addUniqueKvMockPropsOfCurrentReq(htRequestId: string, property: string): void;
+    removeUniqueKvMockPropsOfCurrentReq(htRequestId: string): void;
+    addUniqueManualMockV2IdsOfCurrentReq(htRequestId: string, identifier: string): void;
+    isManualMockV2IdPresentInCurrentReq(htRequestId: string, identifier: string): boolean;
+    removeUniqueManualMockV2IdsOfCurrentReq(htRequestId: string): void;
+    addDiscardedSpan(span: Span): void;
+    getDiscardedSpansMap(): WeakSet<Span>;
+    initialiseUniqueSpanValueHashMap(htRequestId: string): void;
+    addUniqueSpanValueHash(htRequestId: string, spanInfo: SpanInfo): void;
+    removeUniqueSpanValueHash(htRequestId: string): void;
+    initialiseRepeatedSpanValueHashMap(htRequestId: string): void;
+    addRepeatedSpanValueHash(htRequestId: string, spanInfo: SpanInfo): void;
+    removeRepeatedSpanValueHash(htRequestId: string): void;
+    getUniqueSpanValueHashArr(htRequestId: string): {
+        spanId: string;
+        instrumentationName: string;
+        submoduleName: string;
+        inputValueHash: string;
+        outputValueHash: string;
+    }[];
+    getRepeatedSpanValueHashArr(htRequestId: string): {
+        spanId: string;
+        instrumentationName: string;
+        submoduleName: string;
+        inputValueHash: string;
+        outputValueHash: string;
+    }[];
+    setLibsToIgnoreWhileHtSdkInitialise(libsToIgnore: string[]): void;
+    getLibsToIgnoreWhileHtSdkInitialise(): string[];
+    initializePatchedFnInvokeStatus(uniqueFnId: string): void;
+    getPatchedFnInvokeStatus(uniqueFnId: string): boolean;
+    removePatchedFnInvokeStatus(uniqueFnId: string): void;
+    addHttpReqInstrumentationMocks(htRequestId: string, span: Span): void;
+    getHttpReqInstrumentationMocks(htRequestId: string): Span[];
+    deleteHttpReqInstrumentationMocks(htRequestId: string): void;
+    getRootTags(): RootTagType[];
+    addRootTag(payload: RootTagType): void;
+    setHtRequestIdTags(htRequestId: string, payload: RootTagType): boolean;
+    deleteHtRequestIdTags(htRequestId: string): void;
+    getGraphqlServerMock(htRequestId: string): GraphqlServerRequestMock;
+    setGraphqlServerMock(htRequestId: string, graphqlServerMock: GraphqlServerRequestMock): void;
+    deleteGraphqlServerMock(htRequestId: string): void;
+    getIsGraphqlServerBoolean(): boolean;
+    setIsGraphqlServerBoolean(): void;
+    getGraphqlDefinition(gqlOpId: string): Record<string, string>;
+    setGraphqlDefinition(gqlOpId: string, gqlDefn: Record<string, unknown>): void;
+    deleteGraphqlDefinition(gqlOpId: string): boolean;
+    setGraphqlRequestHeaders(htRequestId: string, headers: Record<string, string>): void;
+    getGraphqlRequestHeaders(htRequestId: string): Record<string, string>;
+    deleteGraphqlRequestHeaders(htRequestId: string): void;
+    setTraceId(currentTraceId: string, mainTraceId?: string): void;
+    getTraceId(currentTraceId: string): string | null;
+    deleteTraceId(currentTraceId: string): boolean;
+    setRootMock(value: HtMockMemoryMap): void;
+    getRootMock(): HtMockMemoryMap;
+    isRootMockUpdated(): boolean;
+    getRootReplayMock(): ReplayMockSchemaMap;
+    setRootReplayMock(instrumentationName: string, submoduleName: string, replayMock: HtReplayMockObj): void;
+    deleteRootReplayMock(): void;
+    setRequestMock(requestId: string, value: HtMockMemoryMap): void;
+    getRequestMock(requestId: string): HtMockMemoryMap;
+    removeRequestMock(requestId: string): boolean;
+    setUserMeta(requestId: string, value: JsonableMap): void;
+    getUserMeta(requestId: string): JsonableMap;
+    removeUserMeta(requestId: string): boolean;
+    addDiscardedHtRequestId(htRequestId: HtRequestId): void;
+    removeDiscardedHtRequestId(htRequestId: HtRequestId): boolean;
+    setRequestReplayMock(requestId: string | null, instrumentationName: string, submoduleName: string, replayMock: HtReplayMockObj): void;
+    getRequestReplayMock(requestId: string): ReplayMockSchemaMap;
+    deleteRequestReplayMock(requestId: string): void;
+    setHttpRequestReplayResult(requestId: string, value: HTTPRequestReplayResult): void;
+    getHttpRequestReplayResult(requestId: string): HTTPRequestReplayResult;
+    deleteHttpRequestReplayResult(requestId: string): void;
+    setManualRequestReplayResult(requestId: string, value: ManualRequestReplayResult): void;
+    getManualRequestReplayResult(requestId: string): ManualRequestReplayResult | undefined;
+    deleteManualRequestReplayResult(requestId: string): void;
+    setGraphqlRequestReplayResult(requestId: string, value: GraphqlRequestReplayResult): void;
+    getGraphqlRequestReplayResult(requestId: string): GraphqlRequestReplayResult;
+    deleteGraphqlRequestReplayResult(requestId: string): void;
+    setKafkaRequestReplayResult(requestId: string, value: KafkaRequestReplayResult): void;
+    getKafkaRequestReplayResult(requestId: string): KafkaRequestReplayResult;
+    deleteKafkaRequestReplayResult(requestId: string): void;
+    setGrpcRequestReplayResult(requestId: string, value: GRPCRequestReplayResult): void;
+    getGrpcRequestReplayResult(requestId: string): GRPCRequestReplayResult;
+    deleteGrpcRequestReplayResult(requestId: string): void;
+    setAmqpRequestReplayResult(requestId: string, value: AmqpRequestReplayResult): void;
+    getAmqpRequestReplayResult(requestId: string): AmqpRequestReplayResult;
+    deleteAmqpRequestReplayResult(requestId: string): void;
+    addSpanToChecksumArr(requestId: string, spanId: SpanId): void;
+    initialiseChecksumArr(requestId: string): void;
+    addSpanToTerminatedSpansArr(requestId: string, spanId: SpanId): void;
+    initialiseTerminatedSpansArr(requestId: string): void;
+    getGraphqlNamespaceMap(selectionSetName: string): string;
+    setGraphqlNamespaceMap(selectionSetName: string, htRequestId: string): void;
+    deleteGraphqlNamespaceMap(selectionSetName: string): void;
+    getSelectionSetRequestIds(id: string): GraphqlMetaMap;
+    deleteSelectionSetRequestIds(id: string): void;
+    setSelectionSetRequestIds({ id, htRequestId, topLevelResolverName, selectionSetQuery, fragmentQueries, resolverChain, }: {
+        id: string;
+        htRequestId: string;
+        topLevelResolverName: string;
+        selectionSetQuery: string;
+        fragmentQueries: Record<string, string>[];
+        resolverChain: Set<string>;
+    }): void;
+    getGqlSelectionSetSamplingMode(requestId: string): Record<string, SamplingMode>;
+    setGqlSelectionSetSamplingMode(requestId: string, config: Record<string, SamplingMode>): void;
+    deleteGqlSelectionSetSamplingMode(requestId: string): void;
+    getSpansChecksumArr(requestId: string): SpansChecksumArray;
+    getTerminatedSpansArr(requestId: string): TerminatedSpansArr;
+    getUnterminatedSpans(requestId: string): SpanId[];
+    setAppHealthStatus(status: 'UP' | 'DOWN'): void;
+    getAppHealthStatus(): 'UP' | 'DOWN';
+    setClusterPath(requestId: string, clusterPath: string): void;
+    getClusterPath(requestId: string): string;
+    deleteClusterPath(requestId: string): void;
+    setClusterPathArrForReq(requestId: string, clusterPathArr: RouteObject[]): void;
+    getClusterPathArrForReq(requestId: string): RouteObject[];
+    deleteClusterPathArrForReq(requestId: string): void;
+    setUserDefinedClusterPaths(clusterPaths: Array<{
+        clusterPath: string;
+        regex: RegExp;
+    }>): void;
+    getUserDefinedClusterPaths(): Array<{
+        clusterPath: string;
+        regex: RegExp;
+    }>;
+    setHighPriorityUserClusterPaths(clusterPaths: Array<{
+        clusterPath: string;
+        regex: RegExp;
+    }>): void;
+    getHighPriorityUserClusterPaths(): Array<{
+        clusterPath: string;
+        regex: RegExp;
+    }>;
+    setServerSpanStartTimestamp(requestId: string, serverSpanStartTimestamp: string): void;
+    getServerSpanStartTimestamp(requestId: string): string;
+    setSelectionSet(requestId: string, selectionSet: string): void;
+    getSelectionSet(requestId: string): string;
+    getHtRequestIdExecutionCounter(htRequestId: string): number;
+    updateRequestCoverage(htRequestId: string, filePathAbs: string, lineNumber: string): void;
+    getRequestCoverage(htRequestId: string): {
+        [filePathAbs: string]: {
+            [lineNumber: string]: number[];
+        };
+    };
+    deleteRequestCoverage(htRequestId: string): boolean;
+    setExperimentalFlag(flagName: ExperimentalFlags): void;
+    getExperimentalFlag(flagName: ExperimentalFlags): true;
+    setSpanMetadata(htRequestId: string, spanId: string, data: Partial<{
+        submoduleName: string;
+        packageName: string;
+        readableInput: unknown;
+    }>): void;
+    getSpanMetadata(htRequestId: string, spanId: string): Partial<{
+        submoduleName: string;
+        packageName: string;
+        readableInput: unknown;
+    }>;
+}
+export {};

package/instrumentation/core/helpers/rootMockCounter.d.ts

@@ -0,0 +1,8 @@
+export default class RootMockCounter {
+    private static instance;
+    private count;
+    private constructor();
+    static getInstance(): RootMockCounter;
+    increment(): number;
+    getCount(): number;
+}

package/instrumentation/core/helpers/selectBestMatchMockForReplayHelpers.d.ts

@@ -0,0 +1,7 @@
+import type { JsonSchema } from '../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { HtMockMemoryObj } from '../../../../../utils/types';
+export declare enum MockMatchingCriteria {
+    EXACT_MATCH = "EXACT_MATCH",
+    LEVEN_DIST = "LEVEN_DIST"
+}
+export declare const selectBestMatchMocks: (processedInputJsonSchema: JsonSchema, availableMocks: HtMockMemoryObj[], matchingCriteria: MockMatchingCriteria) => HtMockMemoryObj[];

package/instrumentation/core/helpers/shimmer.d.ts

@@ -0,0 +1,6 @@
+type AnyFunction = Function;
+export declare function wrap(nodule: object, name: string | symbol, wrapper: AnyFunction): (...args: any[]) => unknown;
+export declare function massWrap(nodules: any, names: any, wrapper: any): void;
+export declare function unwrap(nodule: object, name: string): any;
+export declare function massUnwrap(nodules: Record<string, unknown>[], names: string[]): void;
+export {};

package/instrumentation/core/helpers/utils.d.ts

@@ -0,0 +1,56 @@
+import type * as express from 'express';
+import type { FastifyReply } from 'fastify';
+import type { JsonSchema } from '../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import { MockTypeCollector, type RootTagType } from '../../../../../utils/types';
+import type { Jsonable } from '../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentation, HtInstrumentationModuleDefinition, HtShimWrapped } from '../types';
+export declare function isUtf8(input: Buffer): boolean;
+export declare function isWrapped(func: unknown): func is HtShimWrapped;
+export declare const isServerMockType: (mockType: MockTypeCollector) => boolean;
+export declare const HT_DO_NOT_MOCK: symbol;
+export declare const HT_SERVER_TYPE: symbol;
+export declare const IS_ROOT_TRACE_KEY: symbol;
+export declare const DONT_TAMPER_HTTP_REQUEST_HEADERS: symbol;
+export declare const CURRENT_SERVER_MOCK: symbol;
+export declare const HT_REQUEST_ID: symbol;
+export declare const ORIGINAL_FN_ID: symbol;
+export declare const HTTP_PARENT_REQUEST_HEADER = "hypertest-parent-req-id";
+export declare const PARENT_REQUEST_HEADER = "hypertest-parent-req-id";
+export declare const HT_GRAPHQL_OP_ID: symbol;
+export declare function getCurrTraceId(): null | string;
+export declare function isRootTraceFn(): boolean;
+export declare function NOOP(..._args: unknown[]): void;
+export declare function bufferToString(buffer: Buffer): {
+    encoding: HtRawEncoding;
+    bufferStr: string;
+};
+export declare function getObjectHash(obj: Jsonable): string;
+export declare function getSchemaHash(obj: JsonSchema): string;
+export declare function getHtJsonSchema(obj: unknown): JsonSchema;
+export declare function createUnmockedContext(): import("@opentelemetry/api").Context;
+export declare function getCurrentActiveContext(): import("@opentelemetry/api").Context;
+export declare function isUnmockedContext(): boolean;
+export declare function createManualMockContext(): import("@opentelemetry/api").Context;
+export declare function isManualMockContext(): boolean;
+export declare function getHttpClusterPathFromMemStore(): string;
+export declare function createAndSendInstrumentationErrPayload({ args, plugin, functionName, }: {
+    args: unknown;
+    plugin: HtInstrumentation;
+    functionName: string;
+}): void;
+export declare function clearHttpClusterPathFromMemStore(): void;
+export declare const stripQmarkAndTrailingSlashesFromClusterPath: (path: string) => string;
+export declare function setHttpClusterPathInMemStoreAndResHeaders(clusterPath: string, responseObj: express.Response | FastifyReply): void;
+export declare function setTempHttpClusterPathArrForReqInMemStore(): void;
+export declare function getTempHttpClusterPathArrayFromMemStore(): {
+    endpointPath: string;
+    routerFn: import("../../../../../utils/types").AnyFunction;
+}[];
+export declare function deleteHttpClusterPathArrayFromMemStore(): void;
+export declare function calculateSimilarityScoreHelper(similarityObjSource: unknown, similarityObjTarget: unknown, currentDepth: number, depth: number): number;
+export declare function calculateSimilarityScore(similarityObjSource: unknown, similarityObjTarget: unknown, depth: number): number;
+export declare function getModuleVersion<T>(modulesArray: HtInstrumentationModuleDefinition<T>[], packageName: string): string;
+export declare function isMockNotFoundError(error: Error): boolean;
+export declare function pushRootTagToMemoryStore(payload: RootTagType): void;
+export declare function setHtRequestIdTagsIntoStore(htRequestId: string, tag: RootTagType): boolean;
+export declare function deleteHtRequestIdTagsFromStore(htRequestId: string): void;

package/instrumentation/core/types/ExperimentalFlagEnums.d.ts

@@ -0,0 +1,8 @@
+export declare enum ExperimentalFlags {
+    EnableSqlite3Instrumentation = "enableSqlite3Instrumentation",
+    EnableRedisShortSubmoduleName = "enableRedisShortSubmoduleName",
+    EnableMongooseConnectionUnmocking = "enableMongooseConnectionUnmocking",
+    EnableRecordModeExceptionHandling = "enableRecordModeExceptionHandling",
+    EnableElasticV8Instrumentation = "enableElasticV8Instrumentation",
+    EnableInstanceOfPatch = "enableInstanceOfPatch"
+}

package/instrumentation/core/types/HtInstrumentationEnums.d.ts

@@ -0,0 +1,37 @@
+export declare enum HtInstrumentations {
+    HtMysqlInstrumentation = "ht-instrumentation-mysql",
+    HtPgInstrumentation = "ht-instrumentation-pg",
+    HtPrismaInstrumentation = "ht-instrumentation-prisma-client",
+    HtMysql2Instrumentation = "ht-instrumentation-mysql2",
+    HtSocketIoInstrumentation = "ht-instrumentation-socketIo",
+    HtRedisInstrumentation = "ht-instrumentation-redis",
+    HtRedis3Instrumentation = "ht-instrumentation-redis-3",
+    HtKafkaInstrumentation = "ht-instrumentation-kafka",
+    HtAwsSdkInstrumentation = "ht-instrumentation-aws-sdk",
+    HtAmqplibInstrumentation = "ht-instrumentation-amqplib",
+    HtNodemailerInstrumentation = "ht-instrumentation-nodemailer",
+    HtIoredisInstrumentation = "ht-instrumentation-ioredis",
+    HtMongoDbInstrumentation = "ht-instrumentation-mongo",
+    HtMongooseInstrumentation = "ht-instrumentation-mongoose",
+    HtHttpInstrumentation = "ht-instrumentation-http",
+    HtSequelizeInstrumentation = "ht-instrumentation-sequelize",
+    HtGraphqlInstrumentation = "ht-instrumentation-graphql",
+    HtGrpcInstrumentation = "ht-instrumentation-grpc",
+    HtTypeormInstrumentation = "ht-instrumentation-typeorm",
+    HtExpressInstrumentation = "ht-instrumentation-express",
+    HtJsonWebTokenInstrumentation = "ht-instrumentation-jsonwebtoken",
+    HtEtcd3Instrumentation = "ht-instrumentation-etcd3",
+    HtNodeZookeeperClientInstrumentation = "ht-instrumentation-node-zookeeper-client",
+    HtFastifyInstrumentation = "ht-instrumentation-fastify",
+    HtAuth0Instrumentation = "ht-instrumentation-auth0",
+    HtDateInstrumentation = "ht-instrumentation-date",
+    HtElasticSearchInstrumentation = "ht-instrumentation-elastic-search",
+    HtSqlite3Instrumentaion = "ht-instrumentation-sqlite3",
+    HtOpossumInstrumentation = "ht-instrumentation-opossum",
+    HtSentryInstrumentation = "ht-instrumentation-sentry",
+    ManualMock = "ht-instrumentation-manual",
+    ManualMockV2 = "ht-manual-mock-v2",
+    HtKVStore = "ht-kv-store",
+    HtCouchbaseInstrumentation = "ht-instrumentation-couchbase",
+    HtNodeCacheInstrumentation = "ht-instrumentation-node-cache"
+}

package/instrumentation/core/types/HtInstrumentationModuleNames.d.ts

@@ -0,0 +1 @@
+export declare const HtInstrumentationModuleNames: string[];

package/instrumentation/core/types/index.d.ts

@@ -0,0 +1,77 @@
+import type { TracerProvider } from '@opentelemetry/api';
+import type { AnyFunction } from '../../../../../utils/types';
+import type { HtInstrumentations } from './HtInstrumentationEnums';
+export type HtShimWrapped = {
+    __ht_shim_wrapped: boolean;
+    __ht_shim_unwrap: AnyFunction;
+    __ht_shim_original: AnyFunction;
+} & AnyFunction;
+export type HtInstrumentationConfig = {
+    /**
+     * Whether to enable the instrumentation.
+     * @default true
+     */
+    enabled?: boolean;
+    disableInstrumentations?: HtInstrumentations[];
+    ignoredHostsForHttpReqs?: Array<string | RegExp>;
+};
+export type HtInstrumentation = {
+    /** Instrumentation Name  */
+    instrumentationName: string;
+    /**
+     * Instrumentation Description - please describe all useful information
+     * as Instrumentation might patch different version of different modules,
+     * or support different browsers etc.
+     */
+    instrumentationDescription?: string;
+    /**
+     * Contains all supported versions.
+     * All versions must be compatible with [semver](https://semver.org/spec/v2.0.0.html) format.
+     * If the version is not supported, we won't apply instrumentation patch (see `enable` method).
+     * If omitted, all versions of the module will be patched.
+     */
+    supportedVersions?: string[];
+    /** Method to disable the instrumentation  */
+    disable(): void;
+    /** Method to enable the instrumentation  */
+    enable(): void;
+    /** Method to set tracer provider  */
+    setTracerProvider(tracerProvider: TracerProvider): void;
+    /** Method to set instrumentation config  */
+    setConfig(config: HtInstrumentationConfig): void;
+    /** Method to get instrumentation config  */
+    getConfig(): HtInstrumentationConfig;
+};
+export type HtInstrumentationModuleFile<T> = {
+    /** Name of file to be patched with relative path */
+    name: string;
+    moduleExports?: T;
+    /** Supported version this file */
+    supportedVersions: string[];
+    /** Method to patch the instrumentation  */
+    patch(moduleExports: T, moduleVersion?: string): T;
+    /** Method to patch the instrumentation  */
+    /** Method to unpatch the instrumentation  */
+    unpatch(moduleExports?: T, moduleVersion?: string): void;
+};
+export type HtInstrumentationModuleDefinition<T> = {
+    /** Module name or path  */
+    name: string;
+    moduleExports?: T;
+    /** Instrumented module version */
+    moduleVersion?: string;
+    /** Supported version of module  */
+    supportedVersions: string[];
+    /** Module internal files to be patched  */
+    files?: HtInstrumentationModuleFile<unknown>[];
+    /** Method to patch the instrumentation  */
+    patch?: (moduleExports: T, moduleVersion?: string) => T;
+    /** Method to unpatch the instrumentation  */
+    unpatch?: (moduleExports: T, moduleVersion?: string) => void;
+};
+export declare enum FunctionTypeEnum {
+    SYNC = "SYNC",
+    ASYNC = "ASYNC",
+    CALLBACK = "CALLBACK"
+}
+export declare const HT_MOCK_ATTRIBUTE = "ht_mock";

package/instrumentation/helpers/blockRequestsHelpers.d.ts

@@ -0,0 +1,70 @@
+import type { HttpMethodEnum } from '../../../../utils/types';
+type BlockRequestsConfig = {
+    http?: {
+        path: string | RegExp;
+        method?: string;
+    }[];
+    grpc?: {
+        service: string;
+        method: string;
+    }[];
+    kafka?: {
+        groupId: string;
+        topic: string;
+    }[];
+    amqp?: {
+        queue: string;
+    }[];
+    graphql?: {
+        selectionSet: string;
+    }[];
+    manualRequest?: {
+        name: string;
+    }[];
+};
+export declare const processedBlockRequestsConfig: {
+    http: {
+        path: RegExp;
+        method: HttpMethodEnum | '*';
+    }[];
+    grpc: {
+        service: string;
+        method: string;
+    }[];
+    kafka: {
+        groupId: string;
+        topic: string;
+    }[];
+    amqp: {
+        queue: string;
+    }[];
+    graphql: {
+        selectionSet: string;
+    }[];
+    manualRequest: {
+        name: string;
+    }[];
+};
+export declare function setBlockRequestsConfig({ http, grpc, kafka, amqp, graphql, manualRequest, }: BlockRequestsConfig): void;
+export declare function isIncomingHttpRequestBlocked({ incomingRequestPath, incomingRequestMethod, }: {
+    incomingRequestPath: string;
+    incomingRequestMethod: HttpMethodEnum;
+}): boolean;
+export declare function isIncomingGrpcRequestBlocked({ incomingRequestService, incomingRequestMethod, }: {
+    incomingRequestService: string;
+    incomingRequestMethod: string;
+}): boolean;
+export declare function isIncomingKafkaRequestBlocked({ incomingRequestGroupId, incomingRequestTopic, }: {
+    incomingRequestGroupId: string;
+    incomingRequestTopic: string;
+}): boolean;
+export declare function isIncomingAmqpRequestBlocked({ incomingRequestQueue, }: {
+    incomingRequestQueue: string;
+}): boolean;
+export declare function isIncomingGraphqlRequestBlocked({ incomingRequestSelectionSet, }: {
+    incomingRequestSelectionSet: string;
+}): boolean;
+export declare function isIncomingManualRequestBlocked({ incomingRequestName, }: {
+    incomingRequestName: string;
+}): boolean;
+export {};

package/instrumentation/helpers/callbackHelpers.d.ts

@@ -0,0 +1,3 @@
+export type CallbackFn = (...args: unknown[]) => unknown;
+export declare const getCallbackFn: (args: unknown[]) => CallbackFn | null;
+export declare const replaceCallbackFn: (args: unknown[], pathchedCallback: CallbackFn) => unknown[];

package/instrumentation/helpers/commitHash.d.ts

@@ -0,0 +1,3 @@
+export declare const setGitCommitHash: (commitHash: string) => void;
+export declare const setCommitHashFromGit: () => string;
+export declare const getGitCommitHash: () => string;

package/instrumentation/helpers/getConstitentKeysAndTypesMap.d.ts

@@ -0,0 +1,2 @@
+declare const getConsistentKeysAndtypesMap: (input: Record<string, unknown> | unknown[]) => Record<string, string> | Record<string, never>;
+export default getConsistentKeysAndtypesMap;

package/instrumentation/helpers/measureContinuousCoverage.d.ts

@@ -0,0 +1,9 @@
+type MeasureContinuousCoverageConfig = {
+    backendBaseUrl: string;
+    htExtraHeaders?: Record<string, string>;
+    buildId: string;
+    serviceId: string;
+    refreshIntervalInSec?: number;
+};
+export declare const measureContinuousCoverage: ({ backendBaseUrl, htExtraHeaders, buildId, serviceId, refreshIntervalInSec, }: MeasureContinuousCoverageConfig) => void;
+export {};

package/instrumentation/helpers/memoryUsageLimiter.d.ts

@@ -0,0 +1,8 @@
+type MemoryUsageLimiterConfig = {
+    memoryUsageUpperThresholdMB: number;
+    memoryUsageLowerThresholdMB: number;
+    memoryCheckIntervalMs?: number;
+};
+export declare function getShouldDisableSdk(): boolean;
+export declare function setMemoryUsageLimiterConfig(memoryUsageLimiterConfigParam: MemoryUsageLimiterConfig): void;
+export {};