@hypertestco/node-sdk-v3 0.0.1-8

package/instrumentation/core/baseClasses/HtInstrumentationAbstract.d.ts

@@ -0,0 +1,36 @@
+import * as htShimmer from '../helpers/shimmer';
+import type { HtInstrumentationConfig } from '../types';
+import type { HtInstrumentationNodeModule } from './HtInstrumentationNodeModule';
+import { type Tracer, type TracerProvider } from '@opentelemetry/api';
+/**
+ * Base abstract internal class for instrumenting node packages
+ */
+export default abstract class HtInstrumentationAbstract<T> {
+    instrumentationName: string;
+    protected _config: HtInstrumentationConfig;
+    protected _wrap: typeof htShimmer.wrap;
+    protected _unwrap: typeof htShimmer.unwrap;
+    protected _massWrap: typeof htShimmer.massWrap;
+    protected _massUnwrap: typeof htShimmer.massUnwrap;
+    private _tracer;
+    constructor(instrumentationName: string, config?: HtInstrumentationConfig);
+    getConfig(): HtInstrumentationConfig;
+    /**
+     * Sets InstrumentationConfig to this plugin
+     * @param InstrumentationConfig
+     */
+    setConfig(config?: HtInstrumentationConfig): void;
+    /**
+     * Sets TraceProvider to this plugin
+     * @param tracerProvider
+     */
+    setTracerProvider(tracerProvider: TracerProvider): void;
+    get tracer(): Tracer;
+    abstract enable(): void;
+    abstract disable(): void;
+    /**
+     * Init method in which plugin should define _modules and patches for
+     * methods
+     */
+    protected abstract init(): HtInstrumentationNodeModule<T> | HtInstrumentationNodeModule<T>[];
+}

package/instrumentation/core/baseClasses/HtInstrumentationBase.d.ts

@@ -0,0 +1,34 @@
+import type { Debugger } from 'debug';
+import MemoryStore from '../../core/helpers/memoryStore';
+import { type ExecuteOriginalFnWithContextType, type InitOriginalClassWithContextType } from '../helpers/executeFnOrInitClassWithContext';
+import { type massUnwrap, type massWrap, unwrap, wrap } from '../helpers/shimmer';
+import type * as types from '../types';
+import HtInstrumentationAbstract from './HtInstrumentationAbstract';
+/**
+ * Base abstract class for instrumenting node plugins
+ */
+export declare abstract class HtInstrumentationBase<T = unknown> extends HtInstrumentationAbstract<T> implements types.HtInstrumentation {
+    protected readonly IS_RECORD_MODE: boolean;
+    protected readonly IS_REPLAY_MODE: boolean;
+    protected readonly alreadyPatchedSymbol: symbol;
+    readonly _modules: types.HtInstrumentationModuleDefinition<T>[];
+    protected readonly htStore: MemoryStore;
+    protected readonly debug: Debugger;
+    private readonly _hooks;
+    private _enabled;
+    constructor(instrumentationName: string, config?: types.HtInstrumentationConfig);
+    isSupported(supportedVersions: string[], version?: string, includePrerelease?: boolean): boolean;
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    private applyErrorHandlingToPatch;
+    protected _wrap: typeof wrap;
+    protected _unwrap: typeof unwrap;
+    protected _massWrap: typeof massWrap;
+    protected _massUnwrap: typeof massUnwrap;
+    protected readonly executeOriginalFnWithContext: <FunctionType extends (...args: unknown[]) => unknown>(argObj: Omit<ExecuteOriginalFnWithContextType<FunctionType>, "instrumentationName">) => ReturnType<FunctionType>;
+    protected readonly initOriginalClassWithContext: (argObj: Omit<InitOriginalClassWithContextType, "instrumentationName">) => unknown;
+    private _warnOnPreloadedModules;
+    private _extractPackageVersion;
+    private _onRequire;
+}

package/instrumentation/core/baseClasses/HtInstrumentationMockAbstract.d.ts

@@ -0,0 +1,117 @@
+import { type Span, SpanKind, type Tracer } from '@opentelemetry/api';
+import { type Debugger } from '../../../../../utils/commonPackages/debug';
+import { FunctionTypeEnum, type HtMockMemoryObj, type MockType, OutputStatus } from '../../../../../utils/types';
+import type { Jsonable, JsonableMap } from '../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationBase } from './HtInstrumentationBase';
+export type InstrumentationMockReplayValue<RealOutput, OutputMeta> = {
+    output?: RealOutput;
+    outputMeta?: OutputMeta;
+    err?: Error | null;
+    syncCallbackRetVal?: unknown;
+    syncCallbackError: Error | null;
+};
+import type * as types from '../types';
+type ConstructorOfHtInstrumentationMock = new (..._args: unknown[]) => HtInstrumentationMockAbstract;
+type AddStaticMockArgs<InputMeta, ReadableInput, OutputMeta, RealOutput> = {
+    MockClass: ConstructorOfHtInstrumentationMock;
+    minimalMock: MinimalInstrumentationMockObj<InputMeta, ReadableInput, RealOutput, OutputMeta>;
+    shouldPrepend?: boolean;
+    mockSymbol: symbol;
+    mockVersion: number;
+    mockType: MockType;
+};
+export type MinimalInstrumentationMockObj<InputMeta, ReadableInput, RealOutput, OutputMeta> = {
+    inputMeta: InputMeta & JsonableMap;
+    readableInput: ReadableInput & JsonableMap;
+    realOutput?: RealOutput;
+    outputMeta?: OutputMeta & JsonableMap;
+    err?: Error;
+    syncCallbackRetVal?: unknown;
+    syncCallbackError?: Error;
+};
+export declare abstract class HtInstrumentationMockAbstract<InputMeta extends JsonableMap = JsonableMap, ReadableInput extends JsonableMap = JsonableMap, ProcessedInput extends JsonableMap = JsonableMap, ProcessedInputSchema extends JsonableMap = JsonableMap, OutputMeta extends JsonableMap = JsonableMap, RealOutput = any, ReadableOutput extends Jsonable = Jsonable, ProcessedOutputSchema extends Jsonable = JsonableMap, InputValueWithoutLangType extends JsonableMap = JsonableMap, OutputValueWithoutLangType extends JsonableMap = JsonableMap> {
+    static statickMockMap: Map<symbol, HtInstrumentationMockAbstract<JsonableMap, JsonableMap, JsonableMap, JsonableMap, JsonableMap, any, Jsonable, JsonableMap, JsonableMap, JsonableMap>[]>;
+    static addStaticMock<InputMeta extends JsonableMap, ReadableInput extends JsonableMap, OutputMeta extends JsonableMap, RealOutput>({ MockClass, mockType, minimalMock, mockSymbol, mockVersion, shouldPrepend, }: AddStaticMockArgs<InputMeta, ReadableInput, OutputMeta, RealOutput>): void;
+    readonly mockType: MockType;
+    readonly instrumentationName: string;
+    readonly submoduleName: string;
+    readonly packageName: string;
+    protected functionType: FunctionTypeEnum;
+    protected inputMeta: InputMeta;
+    protected readableInput: ReadableInput;
+    protected isReadbleInputSet: boolean;
+    protected debug: Debugger;
+    protected outputMeta?: OutputMeta;
+    protected realOutput?: RealOutput;
+    protected readableOutput?: ReadableOutput;
+    protected isRealOutputSet: boolean;
+    protected err?: Error | null;
+    protected syncCallbackRetVal?: unknown;
+    protected syncCallbackError?: Error | null;
+    protected readonly prioritizeDefaultMock: boolean;
+    protected readonly span: Span | null;
+    protected readonly spanKind: SpanKind;
+    private readonly memoryStoreInst;
+    private readonly globalMockVersion;
+    private readonly mockVersion;
+    private readonly mockSymbol;
+    private readonly shouldRecordFurther;
+    private readonly isStaticMock;
+    private outputStatus;
+    private packageLibVersion?;
+    private isMockSaveFnInvoked;
+    private timeoutId;
+    private tracer;
+    get isReadbleInputSetOnMock(): boolean;
+    constructor({ plugin, mockType, submoduleName, packageName, functionType, prioritizeDefaultMock, mockVersion, mockSymbol, }: {
+        plugin: HtInstrumentationBase | {
+            instrumentationName: string;
+            tracer: Tracer | null;
+            _modules: types.HtInstrumentationModuleDefinition<unknown>[];
+        };
+        mockType: MockType;
+        submoduleName: string;
+        packageName: string;
+        functionType: FunctionTypeEnum;
+        prioritizeDefaultMock?: boolean;
+        mockVersion: number;
+        mockSymbol: symbol;
+    });
+    shouldRecordFurtherFn(): boolean;
+    updateFunctionType(functionType: FunctionTypeEnum): void;
+    updateMockImportance(_isImportantMock: boolean): void;
+    getSpan(): Span | null;
+    setReadableInput(readableInput: ReadableInput, inputMeta: InputMeta): void;
+    setOutput(realOutput: RealOutput, outputMeta: OutputMeta): void;
+    setError(err: Error): void;
+    setSyncCallbackRetVal(syncCallbackRetVal: unknown): void;
+    setSyncCallbackError(syncCallbackError: Error): void;
+    clone(): void;
+    private addAttibutesToSpan;
+    save(): void;
+    getReplayValue(shouldLogMockNotFoundError?: boolean): InstrumentationMockReplayValue<RealOutput, OutputMeta>;
+    getOutputStatus(): OutputStatus;
+    abstract generateProcessedInput(): ProcessedInput;
+    abstract generateProcessedInputSchema(): ProcessedInputSchema;
+    protected generateInputValueWithoutLangType?(): InputValueWithoutLangType;
+    abstract generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    abstract generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+    protected generateOutputValueWithoutLangType?(realOutput: RealOutput): OutputValueWithoutLangType;
+    protected getUnusedTraceMockIndexByInputValueHash(mocksArr: HtMockMemoryObj[]): number;
+    protected getUsedTraceMockIndexByInputValueHash(mocksArr: HtMockMemoryObj[]): number;
+    protected getUnusedTraceMockIndexByInputSchemaHash(mocksArr: HtMockMemoryObj[]): number;
+    protected getUsedTraceMockIndexByInputSchemaHash(mocksArr: HtMockMemoryObj[]): number;
+    protected findMostSimilarMockIndex(mocksArr: Array<{
+        mock: HtMockMemoryObj;
+        index: number;
+    }>): number;
+    private findNonErrorMock;
+    private setReplayValueAndGetMockRetVal;
+    private selectBestNearestMockForReplay;
+    private selectRootMockForReplay;
+    private selectTraceMockForReplay;
+    private handleMockNotFound;
+    private getStaticMockForReplay;
+    private setReplayMock;
+}
+export {};

package/instrumentation/core/baseClasses/HtInstrumentationMockAbstractForAxiosError.d.ts

@@ -0,0 +1,11 @@
+import type { AxiosRequestHeaders } from 'axios';
+import type { Jsonable, JsonableMap } from '../../../../../../utils/types/jsonableTypes';
+import { HtInstrumentationMockAbstract } from './HtInstrumentationMockAbstract';
+type OriginalError = Error & {
+    isAxiosError?: boolean;
+    toJSON?: () => AxiosRequestHeaders;
+};
+export declare abstract class HtInstrumentationMockAbstractForAxiosError<InputMeta extends JsonableMap = JsonableMap, ReadableInput extends JsonableMap = JsonableMap, ProcessedInput extends JsonableMap = JsonableMap, ProcessedInputSchema extends JsonableMap = JsonableMap, OutputMeta extends JsonableMap = JsonableMap, RealOutput = any, ReadableOutput extends Jsonable = Jsonable, ProcessedOutputSchema extends Jsonable = Jsonable, InputValueWithoutLangType extends JsonableMap = JsonableMap, OutputValueWithoutLangType extends JsonableMap = JsonableMap> extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema, InputValueWithoutLangType, OutputValueWithoutLangType> {
+    setError(err: OriginalError): void;
+}
+export {};

package/instrumentation/core/baseClasses/HtInstrumentationNodeModule.d.ts

@@ -0,0 +1,9 @@
+import type { HtInstrumentationModuleDefinition, HtInstrumentationModuleFile } from '../types';
+export declare class HtInstrumentationNodeModule<T> implements HtInstrumentationModuleDefinition<T> {
+    name: string;
+    supportedVersions: string[];
+    patch?: (exports: T, moduleVersion?: string) => T;
+    unpatch?: (exports: T, moduleVersion?: string) => void;
+    files?: HtInstrumentationModuleFile<T>[];
+    constructor(name: string, supportedVersions: string[], patch?: (exports: T, moduleVersion?: string) => T, unpatch?: (exports: T, moduleVersion?: string) => void, files?: HtInstrumentationModuleFile<T>[]);
+}

package/instrumentation/core/baseClasses/HtInstrumentationNodeModuleFile.d.ts

@@ -0,0 +1,8 @@
+import type { HtInstrumentationModuleFile } from '../types';
+export declare class HtInstrumentationNodeModuleFile<T> implements HtInstrumentationModuleFile<T> {
+    supportedVersions: string[];
+    patch: (moduleExports: T, moduleVersion?: string) => T;
+    unpatch: (moduleExports: T, moduleVersion?: string) => void;
+    name: string;
+    constructor(name: string, supportedVersions: string[], patch: (moduleExports: T, moduleVersion?: string) => T, unpatch: (moduleExports: T, moduleVersion?: string) => void);
+}

package/instrumentation/core/baseClasses/HtServerMockAbstract.d.ts

@@ -0,0 +1,68 @@
+import { type Span, type SpanKind } from '@opentelemetry/api';
+import { type FunctionTypeEnum, MockTypeCollector, type OutputStatus, type RequestType } from '../../../../../utils/types';
+import type { Jsonable, JsonableMap } from '../../../../../utils/types/jsonableTypes';
+import { type Debugger } from '../../../../../utils/commonPackages/debug';
+import type { JsonSchema } from '../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { HtInstrumentationBase } from './HtInstrumentationBase';
+export declare abstract class HtServerMockAbstract<InputMeta extends JsonableMap, ReadableInput extends JsonableMap, ProcessedInput extends JsonableMap, ProcessedInputSchema extends JsonableMap, OutputMeta extends JsonableMap, RealOutput, ProcessedOutputSchema extends Jsonable, InputValueWithoutLangType extends JsonableMap = JsonableMap, OutputValueWithoutLangType extends Jsonable = Jsonable, UserMeta extends JsonableMap = JsonableMap> {
+    readonly requestType: RequestType;
+    readonly instrumentationName: string;
+    readonly submoduleName: string;
+    protected readonly functionType: FunctionTypeEnum;
+    protected inputMeta: InputMeta;
+    protected readableInput: ReadableInput;
+    protected outputMeta: OutputMeta;
+    protected realOutput?: RealOutput;
+    protected userMeta: UserMeta;
+    spanCreationTimeMs: number;
+    protected realOutputKeyedHtJsonSchema?: Record<keyof RealOutput extends string ? string : string, JsonSchema>;
+    protected readonly span: Span;
+    protected parentHtRequestId: string;
+    protected debug: Debugger;
+    private isMockSaved;
+    private outputStatus;
+    readonly packageLibVersion?: string;
+    readonly packageName: string;
+    private isMockSaveFnInvoked;
+    private timeoutId;
+    protected isReadbleInputSet: boolean;
+    private mockType;
+    constructor({ plugin, packageName, submoduleName, mockType, spanKind, }: {
+        plugin: HtInstrumentationBase | (Pick<HtInstrumentationBase, 'instrumentationName' | 'tracer' | '_modules'> & {
+            IS_RECORD_MODE: boolean;
+            IS_REPLAY_MODE: boolean;
+        });
+        packageName: string;
+        submoduleName: string;
+        mockType: MockTypeCollector;
+        spanKind: SpanKind.SERVER | SpanKind.CONSUMER;
+    });
+    getSpan(): Span;
+    applyBeforeRecordInputHook(readableInput: ReadableInput, inputMeta: InputMeta, userMeta: UserMeta): {
+        readableInput: ReadableInput;
+        inputMeta: InputMeta;
+        userMeta: UserMeta;
+    };
+    setReadableInput(readableInput: ReadableInput, inputMeta: InputMeta, parentHtRequestId?: string): void;
+    getRealOutputKeyedHtJsonSchema<T>(): T;
+    applyBeforeRecordOutputHook(realOutput: RealOutput, outputMeta: OutputMeta, userMeta: UserMeta): {
+        realOutput: RealOutput;
+        outputMeta: OutputMeta;
+        userMeta: UserMeta;
+    };
+    applyBeforeReplayOutputHook(realOutput: RealOutput, outputMeta: OutputMeta, userMeta: UserMeta): {
+        realOutput: RealOutput;
+        outputMeta: OutputMeta;
+        userMeta: UserMeta;
+    };
+    setRealOutput(realOutput: RealOutput, outputMeta: OutputMeta): void;
+    getReadableInput(): ReadableInput;
+    getProcessedOutputSchema(): ProcessedOutputSchema;
+    save(): void;
+    abstract generateProcessedInput(): ProcessedInput;
+    abstract generateProcessedInputSchema(): ProcessedInputSchema;
+    protected generateInputValueWithoutLangType?(): InputValueWithoutLangType;
+    abstract generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+    protected generateOutputValueWithoutLangType?(realOutput: RealOutput): OutputValueWithoutLangType;
+    abstract generateOutputStatus(realOutput: RealOutput): OutputStatus;
+}

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

@@ -0,0 +1,12 @@
+export declare const ALREADY_PATCHED_SYMBOL: symbol;
+export declare const DONT_RECORD_FURTHER: symbol;
+export declare const SAMPLING_MODE_CONTEXT_KEY: symbol;
+export declare const SHOULD_INSTRUMENT_DATE: symbol;
+export declare const HYPERTEST_SAMPLING_MODE_HEADER = "hypertest-sampling-mode";
+export declare enum SAMPLING_MODE_HEADER_VALUES {
+    BLOCK_LOCAL = "block-local",
+    RECORD_LOCAL = "record-local",
+    RECORD_TRACE = "record-trace"
+}
+declare let IS_ESM_APP: boolean;
+export { IS_ESM_APP };

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

@@ -0,0 +1,21 @@
+import { type Context, type Span, SpanKind, type TimeInput, type Tracer } from '@opentelemetry/api';
+import type { MockTypeCollector } from '../../../../../utils/types';
+export declare function defaultAttributesForSpan(mockType: MockTypeCollector): {
+    mockType: MockTypeCollector;
+    sdkType: any;
+    serviceId: string;
+    envName: string;
+};
+export type CreateNewSpanHelperInput = {
+    tracer: Tracer;
+    instrumentationName: string;
+    submoduleName: string;
+    packageName: string;
+    mockType: MockTypeCollector;
+    attributes?: Record<string, string>;
+    spanKind?: SpanKind;
+    currContext?: Context;
+    startTime?: TimeInput;
+};
+declare const createNewSpanHelper: ({ tracer, instrumentationName, submoduleName, packageName, mockType, attributes, spanKind, currContext, startTime, }: CreateNewSpanHelperInput) => Span | null;
+export default createNewSpanHelper;

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

@@ -0,0 +1,23 @@
+import { type Span } from '@opentelemetry/api';
+export type ExecuteOriginalFnWithContextType<T extends (...args: unknown[]) => unknown> = {
+    fn: T;
+    thisValue: unknown;
+    argsArr: unknown[];
+    instrumentationName: string;
+    submoduleName: string;
+    stopRecordingChildSpans?: boolean;
+    span?: Span | null;
+    nonCallbackFuncIndexes?: number[];
+};
+type Constructable = new (..._args: unknown[]) => unknown;
+export type InitOriginalClassWithContextType = {
+    Class: Constructable;
+    argsArr: unknown[];
+    instrumentationName: string;
+    submoduleName: string;
+    stopRecordingChildSpans?: boolean;
+    span?: Span | null;
+};
+export declare const executeOriginalFnWithContext: <T extends (..._args: unknown[]) => unknown>({ fn, thisValue, argsArr, instrumentationName, submoduleName, stopRecordingChildSpans, span, nonCallbackFuncIndexes, }: ExecuteOriginalFnWithContextType<T>) => ReturnType<T>;
+export declare const initOriginalClassWithContext: ({ Class, argsArr, instrumentationName, submoduleName, stopRecordingChildSpans, span, }: InitOriginalClassWithContextType) => unknown;
+export {};

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

@@ -0,0 +1,2 @@
+import type { MockTypeCollector } from '../../../../../utils/types';
+export declare function generateCtxWithHtRequestId(preCalculatedHtRequestId?: string, serverType?: MockTypeCollector): import("@opentelemetry/api").Context;

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

@@ -0,0 +1,9 @@
+/**
+ * Returns context to use for server instrumentation based on config option:
+ * useRootContextForServerMocks ? ROOT_CONTEXT : context.active()
+ *
+ * This "useRootContextForServerMocks" option should be enabled for some frameworks(e.g., sailsjs)
+ * which messes up the context of server requests
+ */
+declare const _default: () => import("@opentelemetry/api").Context;
+export default _default;

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

@@ -0,0 +1,6 @@
+import { HT_MODES } from '../../../../../utils/types';
+export { HT_MODES };
+export declare const getHtMode: () => HT_MODES;
+export declare let IS_REPLAY_MODE: boolean;
+export declare let IS_RECORD_MODE: boolean;
+export declare function updateHtMode(): void;

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

@@ -0,0 +1 @@
+export declare const IS_INSTRUMENTATION_TESTING_ENABLED: boolean;