@loadmill/executer 0.1.50 → 0.1.53

package/src/post-script/post-script-executor.ts

@@ -1,89 +0,0 @@
-import { strict as assert } from 'assert';
-import { SequenceExecutorParameters } from '@loadmill/core/dist/parameters';
-import { ParameterFunctionOperations } from '@loadmill/core/dist/parameters/parameter-functions/parameter-functions';
-import { ASTWalker } from './ast-walker';
-import { VM2VirtualMachine } from './virtual-machine/vm2-virtual-machine';
-
-export class PostScriptRunner {
-  public run = (
-    staticContext: OuterStaticContext = { staticContext: { $: {}, __: {} } },
-    dynamicContext: SequenceExecutorParameters = {},
-    userCode: string = ''
-  ): SequenceExecutorParameters => {
-    const newVariables = new ASTWalker(userCode).detectDeclarations(Object.keys(staticContext));
-    const wrappedUserCode = this.wrapUserCode(dynamicContext, userCode, newVariables);
-    const vm = new VM2VirtualMachine();
-    vm.create({
-      globalObject: { assert, ...dynamicContext },
-      staticObject: staticContext,
-    });
-
-    const modifiedDynamicContext = vm.run(wrappedUserCode);
-    this.validateCircularDependency(modifiedDynamicContext);
-    this.removeAssertModule(modifiedDynamicContext);
-    return modifiedDynamicContext;
-  };
-
-  private wrapUserCode = (
-    dynamicContext: SequenceExecutorParameters = {},
-    userCode: string = '',
-    newVariables: string[] = []
-  ) => {
-    const prefix =
-    `
-      Buffer = {};
-      global = { assert: global.assert };
-      const $ = staticContext.$;
-      const __ = staticContext.__;
-    `;
-
-    const suffix =
-    `
-      exports = {
-      ${[...Object.keys(dynamicContext), ...newVariables].join()}
-      };
-    `;
-
-    return prefix + userCode + suffix;
-  }
-
-  validateCircularDependency = (obj: SequenceExecutorParameters) => {
-    function circularError (propName: string) {
-      return new TypeError(`Cyclic object value. Circular reference in property ${propName}`);
-    }
-
-    findCircular(obj);
-
-    function findCircular(
-      obj: SequenceExecutorParameters,
-      _refs: WeakSet<SequenceExecutorParameters> = new WeakSet()
-    ) {
-      if (typeof obj === 'object' && obj !== null) {
-        _refs.add(obj);
-        for (const key in obj) {
-          if (_refs.has(obj[key])) {
-            throw circularError(key);
-          }
-          findCircular(obj[key], _refs);
-        }
-        _refs.delete(obj);
-      }
-    }
-  };
-
-  private removeAssertModule(context: SequenceExecutorParameters) {
-    Object.keys(context).forEach(key => {
-      if (context[key]?.assert?.name === 'strict') {
-        context[key] = {};
-      }
-    });
-  }
-}
-type OuterStaticContext = {
-  staticContext: StaticContext;
-};
-
-type StaticContext = {
-  $: SequenceExecutorParameters;
-  __: ParameterFunctionOperations;
-};

package/src/post-script/virtual-machine/virtual-machine.ts

@@ -1,15 +0,0 @@
-export interface VirtualMachine {
-  engine: Engine;
-  create(options: VirtualMachineOptions): Engine;
-  run(code: string): object;
-}
-
-export interface VirtualMachineOptions {
-  globalObject?: object;
-  staticObject?: object;
-  timeout?: number;
-  memoryLimit?: number;
-  async?: boolean;
-}
-
-export type Engine = any;

package/src/post-script/virtual-machine/vm2-virtual-machine.ts

@@ -1,45 +0,0 @@
-import { VM } from 'vm2';
-import { SequenceExecutorParameters } from '../../../../core/dist/parameters';
-
-import { Engine, VirtualMachine, VirtualMachineOptions } from './virtual-machine';
-
-export class VM2VirtualMachine implements VirtualMachine {
-  public engine: VM;
-  private DEFAULT_TIMOUT_MS = Number(process.env.POSTSCRIPT_TIMEOUT_MS) || 1000;
-
-  create(options: VirtualMachineOptions): Engine {
-    const { timeout, globalObject, async, staticObject } = options;
-    this.engine = new VM({
-      timeout: timeout || this.DEFAULT_TIMOUT_MS,
-      fixAsync: !async,
-      eval: false,
-      wasm: false,
-    });
-
-    this.makeStatic(staticObject);
-
-    this.setGlobals(globalObject);
-  }
-
-  makeStatic(obj: object = {}) {
-    this.deepFreeze(obj);
-  }
-
-  deepFreeze = (obj: object) => {
-    for (const key of Object.keys(obj)) {
-      if (typeof obj[key] === 'object' && obj[key] !== null) {
-        this.engine.freeze(obj[key], key); // freeze me
-        this.deepFreeze(obj[key]); // freeze my childrens
-      }
-    }
-    return this.engine.freeze(obj); // freeze root
-  };
-
-  setGlobals = (globalObject: SequenceExecutorParameters = {}) => {
-    this.engine.setGlobals(globalObject);
-  }
-
-  run(code: string): SequenceExecutorParameters {
-    return this.engine.run(code);
-  }
-}

package/src/report-types.ts

@@ -1,127 +0,0 @@
-import { Failures } from './failures';
-import { MillInfo } from './mill-info';
-import { PerRequestResTime, PerRequestStats } from './request-stats';
-
-export type LoadResult = 'done' | 'aborted' | 'failed';
-
-/**
- * This report contains all the info that comes from Redis each time there is a status update.
- */
-export interface LoadStatusReport extends AggregatedStatsReport {
-  endTime?: number;
-  startTime?: number;
-  result?: LoadResult;
-  activeSessions?: number;
-}
-
-/**
- * This report contains all the aggregated stats computed from individual mill reports.
- */
-export interface AggregatedStatsReport extends BasicStatsReport {
-  /**
-   * The number of separate sessions / mills that sent at least one report.
-   */
-  reportedSessions?: number;
-
-  append?: boolean;
-  failures?: Failures;
-  browserStatsMap?: StatsMap;
-  locationStatsMap?: StatsMap;
-  serverMetrics?: ServerMetrics;
-  avgResTimeSequence?: SequenceObj;
-  requestStats?: PerRequestResTime;
-  failureReportsMap?: HashKeysToReportIds;
-}
-
-/**
- * A mapping that aggregates stats according to a certain feature, e.g. stats per browser version.
- */
-export interface StatsMap {
-  [feature: string]: BasicStatsReport & {
-    sessions: number;
-  };
-}
-
-/**
- * A sequence of stats (currently only the average response time) reported within a certain
- * interval (between `firstTime` and `lastTime`).
- */
-export interface SequenceObj {
-  append?: boolean;
-  sequence: ClientMetrics;
-}
-
-export type ClientMetrics = ClientMetricsClump[];
-
-export type ClientMetricsClump = {
-  s?: number;
-  f?: number;
-  avg: number;
-  time: number;
-  p50?: number;
-  p95?: number;
-  weight: number;
-  concurrency: number;
-};
-
-export type ServerMetrics = ServerMetricsClump[];
-
-export type ServerMetricsClump = {
-  _t: number;
-
-  uc?: number;
-  tc?: number;
-
-  tm?: number;
-  hm?: number;
-  uhm?: number;
-};
-
-export type HashKeysToReportIds = { [hashKey: string]: string };
-
-/**
- * This is the report sent to Redis every time a mill report is received.
- */
-export type ToStoreStatsReport = StatsReportWithMillInfo & {
-  timestamp: number;
-  firstReport: boolean;
-};
-
-/**
- * This report includes a single mill stats report along with additional meta data.
- */
-export type StatsReportWithMillInfo = FromMillStatsReport &
-  MillInfo & {
-    lordId: string;
-  };
-
-/**
- * The stats report sent by the mill.
- */
-export interface FromMillStatsReport extends BasicStatsReport {
-  failures?: Failures;
-  requestStats?: PerRequestStats;
-}
-
-/**
- * The basic stats we are usually interested in.
- */
-export interface BasicStatsReport {
-  hits?: number;
-  avgResTime?: number;
-  failedIterations?: number;
-  successfulIterations?: number;
-}
-
-export function isInformative({
-  hits,
-  avgResTime,
-  failedIterations,
-  successfulIterations,
-}: FromMillStatsReport) {
-  return (
-    (hits && hits > 0 && avgResTime != null && avgResTime >= 0) ||
-    (failedIterations && failedIterations > 0) ||
-    (successfulIterations && successfulIterations > 0)
-  );
-}

package/src/request-sequence-result.ts

@@ -1,63 +0,0 @@
-import { Failures } from './failures';
-import { PerRequestStats } from './request-stats';
-import { Parameters } from '@loadmill/core/dist/parameters';
-import {
-  LoadmillHeaders,
-  LoadmillRequest,
-  PostFormData,
-  RequestPostData,
-} from '@loadmill/core/dist/request';
-
-export function extendSequenceResult(
-  result: RequestSequenceResult,
-  requests: LoadmillRequest[]
-): ExtendedSequenceResult {
-  return {
-    ...result,
-    resolvedRequests: requests.map((request, index: number) => ({
-      ...request,
-      ...result.resolvedRequests[index],
-    })),
-  };
-}
-
-export interface ExtendedSequenceResult extends RequestSequenceResult {
-  resolvedRequests: ExtendedRequest[];
-  err?: string;
-}
-
-export interface RequestSequenceResult {
-  failures: Failures;
-  avgResTime: number;
-  successfulHits: number;
-  lastStartedIndex: number;
-  requestStats: PerRequestStats;
-  resolvedRequests: ResolvedRequest[];
-}
-
-export type ExtendedRequest = LoadmillRequest & ResolvedRequest;
-
-export interface ResolvedRequest {
-  url?: string;
-  headers?: LoadmillHeaders[];
-  postData?: RequestPostData;
-  postFormData?: PostFormData;
-
-  response?: {
-    type: string;
-    text: string;
-    status: number;
-    statusText: string;
-    headers: LoadmillHeaders[];
-  };
-
-  postParameters?: Parameters[];
-
-  unexpectedError?: {
-    stack: string;
-    message: string;
-    properties: string;
-  };
-
-  retried?: number;
-}

package/src/request-stats.ts

@@ -1,20 +0,0 @@
-export interface PerRequestStats {
-  [index: number]: RequestStats;
-}
-
-export interface RequestStats {
-  resTimes: number[];
-}
-
-export interface PerRequestResTime {
-  [index: number]: { weight: number; avg: number };
-}
-
-export function setReqStats(
-  reqStats: PerRequestStats,
-  index,
-  ...resTimes: number[]
-) {
-  const stats = reqStats[index] || (reqStats[index] = { resTimes: [] });
-  stats.resTimes.push(...resTimes);
-}

package/src/res-keeper.ts

@@ -1,53 +0,0 @@
-import { ObjectMap } from '@loadmill/universal/dist/object-map';
-import * as promiseUtils from '@loadmill/universal/dist/promise-utils';
-import { getFailureKeys } from './failures';
-import { RequestSequenceResult } from './request-sequence-result';
-
-export class ResKeeper {
-  knownKeysToResults: { [key: string]: string } = {};
-  results = new ObjectMap<RequestSequenceResult>(this.generateResultKey);
-
-  constructor(private generateResultKey?) {}
-
-  getKnownKeys = () => Object.keys(this.knownKeysToResults);
-
-  mapToResultIds = (failureKeys) => {
-    const map: { [key: string]: string } = {};
-    failureKeys.forEach((key) => (map[key] = this.knownKeysToResults[key]));
-
-    return map;
-  };
-
-  keepIfNeeded = (result: RequestSequenceResult, keepFor?: number) => {
-    const failureKeys = getFailureKeys(result.failures);
-
-    if (failureKeys.find((key) => !this.knownKeysToResults[key])) {
-      // We keep it:
-      const id = this.results.add(result);
-      failureKeys.forEach((key) => (this.knownKeysToResults[key] = id));
-
-      if (keepFor) {
-        promiseUtils.delay(keepFor).then(() => this.results.remove(id));
-      }
-    }
-  };
-
-  popForKeys = (failureKeys: string[], withIds = false) => {
-    return failureKeys
-      .map((key) => {
-        const id = this.knownKeysToResults[key];
-
-        if (id) {
-          const res = this.results.get(id);
-          this.results.remove(id);
-
-          if (withIds && res) {
-            res['id'] = id;
-          }
-
-          return res;
-        }
-      })
-      .filter(Boolean);
-  };
-}

package/src/sampler.ts

@@ -1,133 +0,0 @@
-import log from '@loadmill/universal/dist/log';
-import * as mathUtils from '@loadmill/universal/dist/math-utils';
-import * as promiseUtils from '@loadmill/universal/dist/promise-utils';
-import { minimalRemainingDuration, reportDelay } from '@loadmill/core/dist/conf';
-import { runSingleIteration } from './single-runner';
-import { Failures, mergeFailures } from './failures';
-import { PerRequestStats, setReqStats } from './request-stats';
-import { Work } from './work';
-import { messageCreators } from './message-creators';
-import { DEFAULT_DURATION, DEFAULT_ITERATION_DELAY } from '@loadmill/core/dist/conf/defaults';
-
-// 5 minutes:
-const RES_KEEP_TIME = 5 * 60 * 1000;
-
-export interface SamplerFaja {
-  cancelWork(finished: boolean);
-  send(obj: string);
-  reportIntervalId;
-  isStopped: boolean;
-  keeper;
-}
-
-export class Sampler {
-  avgResTime = 0;
-  expired = false;
-  successfulHits = 0;
-  failedIterations = 0;
-  startedIterations = 0;
-  failures: Failures = {};
-  successfulIterations = 0;
-  requestStats: PerRequestStats = {};
-
-  constructor(private samplerMill: SamplerFaja, private work: Work) {}
-
-  startSampling = () => {
-    this.samplerMill.cancelWork(false);
-
-    promiseUtils.delay(this.work.duration || DEFAULT_DURATION).then(
-      () => {
-        if (!this.samplerMill.isStopped) {
-          log.debug('Time\'s up!');
-          this.expired = true;
-          this.sendReport();
-        }
-      }
-    );
-
-    const requests = this.work.requests;
-    const iterationDelay = this.work.iterationDelay || DEFAULT_ITERATION_DELAY;
-
-    const reportDelayy = reportDelay(iterationDelay, requests);
-    this.samplerMill.reportIntervalId = setInterval(
-      this.sendReport,
-      reportDelayy
-    );
-
-    this.samplerMill.isStopped = false;
-    this.runAll();
-  };
-
-  runAll = async () => {
-    while (!this.isDone()) {
-      ++this.startedIterations;
-      log.trace('Executing iteration: ', this.startedIterations);
-
-      const res = await runSingleIteration(this.work);
-      this.samplerMill.keeper.keepIfNeeded(res, RES_KEEP_TIME);
-
-      const resFailures = res.failures;
-
-      if (!resFailures || Object.keys(resFailures).length === 0) {
-        ++this.successfulIterations;
-      } else {
-        ++this.failedIterations;
-        mergeFailures(this.failures, resFailures);
-      }
-
-      this.avgResTime = mathUtils.calcAvg(
-        this.avgResTime,
-        this.successfulHits,
-        res.avgResTime,
-        res.successfulHits
-      );
-      this.successfulHits += res.successfulHits;
-
-      Object.keys(res.requestStats).forEach(index => {
-        setReqStats(this.requestStats, index, ...res.requestStats[index].resTimes);
-      });
-
-
-      if (!this.isDone()) {
-        // We count only the delay of the requests that were NOT ATTEMPTED.
-        // Note that the first request delay is always ignored:
-        const skipCount = res.lastStartedIndex + 1;
-        await promiseUtils.delay(
-          minimalRemainingDuration(
-            this.work.iterationDelay || DEFAULT_ITERATION_DELAY,
-            this.work.requests,
-            skipCount
-          )
-        );
-      }
-    }
-
-    if (!this.samplerMill.isStopped) {
-      log.debug('Finished last iteration:', this.startedIterations);
-      this.sendReport();
-      this.samplerMill.cancelWork(true);
-    }
-  };
-
-  isDone = () => {
-    return this.samplerMill.isStopped || this.expired || this.startedIterations >= this.work.iterations;
-  };
-
-  sendReport = () => {
-    const report = {
-      failures: this.failures,
-      hits: this.successfulHits,
-      avgResTime: this.avgResTime,
-      requestStats: this.requestStats,
-      failedIterations: this.failedIterations,
-      successfulIterations: this.successfulIterations,
-    };
-
-    log.trace('Sending report:', report);
-    this.samplerMill.send(messageCreators.report(report));
-
-    this.failures = {};
-    this.requestStats = {};
-    this.successfulIterations = this.successfulHits = this.failedIterations = this.avgResTime = 0;
-  };
-}