@elastic/synthetics 1.0.0-beta.4 → 1.0.0-beta.41

package/src/core/logger.ts

@@ -23,20 +23,9 @@
  *
  */
 
-import SonicBoom from 'sonic-boom';
 import { grey, cyan, dim, italic } from 'kleur/colors';
 import { now } from '../helpers';
 
-const defaultFd = process.stdout.fd;
-let logger = new SonicBoom({ fd: defaultFd, sync: true });
-
-export const setLogger = (fd: number) => {
-  if (fd && fd !== defaultFd) {
-    logger = new SonicBoom({ fd });
-  }
-  return logger;
-};
-
 export function log(msg) {
   if (!process.env.DEBUG || !msg) {
     return;
@@ -45,5 +34,5 @@ export function log(msg) {
     msg = JSON.stringify(msg);
   }
   const time = dim(cyan(`at ${parseInt(String(now()))} ms `));
-  logger.write(time + italic(grey(msg)) + '\n');
+  console.log(time + italic(grey(msg)) + '\n');
 }

package/src/core/runner.ts

@@ -23,7 +23,6 @@
  *
  */
 
-import { once, EventEmitter } from 'events';
 import { join } from 'path';
 import { mkdir, rm, writeFile } from 'fs/promises';
 import { Journey } from '../dsl/journey';
@@ -37,106 +36,50 @@ import {
   generateUniqueId,
 } from '../helpers';
 import {
-  StatusValue,
   HooksCallback,
   Params,
-  PluginOutput,
-  CliArgs,
   HooksArgs,
+  Driver,
+  Screenshot,
+  RunOptions,
+  JourneyResult,
+  StepResult,
 } from '../common_types';
 import { PluginManager } from '../plugins';
-import { PerformanceManager, Metrics } from '../plugins';
-import { Driver, Gatherer } from './gatherer';
+import { PerformanceManager } from '../plugins';
+import { Gatherer } from './gatherer';
 import { log } from './logger';
+import { Monitor, MonitorConfig } from '../dsl/monitor';
 
-export type RunOptions = Omit<
-  CliArgs,
-  | 'debug'
-  | 'json'
-  | 'pattern'
-  | 'inline'
-  | 'require'
-  | 'suiteParams'
-  | 'reporter'
-  | 'richEvents'
-  | 'capability'
-> & {
-  environment?: string;
-  params?: Params;
-  reporter?: CliArgs['reporter'] | Reporter;
-};
+type HookType = 'beforeAll' | 'afterAll';
+export type SuiteHooks = Record<HookType, Array<HooksCallback>>;
 
-type BaseContext = {
+type JourneyContext = {
   params?: Params;
   start: number;
-  end?: number;
-};
-
-type JourneyContext = BaseContext & {
   driver: Driver;
   pluginManager: PluginManager;
 };
 
-type StepResult = {
-  status: StatusValue;
-  url?: string;
-  metrics?: Metrics;
-  error?: Error;
-};
-
-type JourneyResult = {
-  status: StatusValue;
-  error?: Error;
-};
-
 type RunResult = Record<string, JourneyResult>;
 
-type HookType = 'beforeAll' | 'afterAll';
-export type SuiteHooks = Record<HookType, Array<HooksCallback>>;
-
-interface Events {
-  start: { numJourneys: number };
-  'journey:register': {
-    journey: Journey;
-  };
-  'journey:start': {
-    journey: Journey;
-    timestamp: number;
-    params: Params;
-  };
-  'journey:end': BaseContext &
-    JourneyResult &
-    PluginOutput & {
-      journey: Journey;
-      options: RunOptions;
-    };
-  'journey:end:reported': unknown;
-  'step:start': { journey: Journey; step: Step };
-  'step:end': StepResult & {
-    start: number;
-    end: number;
-    journey: Journey;
-    step: Step;
-  };
-  end: unknown;
-}
-
-export default interface Runner {
-  on<K extends keyof Events>(name: K, listener: (v: Events[K]) => void): this;
-  emit<K extends keyof Events>(event: K, args: Events[K]): boolean;
-}
-
-export default class Runner extends EventEmitter {
-  active = false;
-  currentJourney?: Journey = null;
+export default class Runner {
+  #active = false;
+  #reporter: Reporter;
+  #currentJourney?: Journey = null;
   journeys: Journey[] = [];
   hooks: SuiteHooks = { beforeAll: [], afterAll: [] };
   hookError: Error | undefined;
+  monitor?: Monitor;
   static screenshotPath = join(CACHE_PATH, 'screenshots');
 
   static async createContext(options: RunOptions): Promise<JourneyContext> {
-    const start = monotonicTimeInSeconds();
     const driver = await Gatherer.setupDriver(options);
+    /**
+     * Do not include browser launch/context creation duration
+     * as part of journey duration
+     */
+    const start = monotonicTimeInSeconds();
     const pluginManager = await Gatherer.beginRecording(driver, options);
     /**
      * For each journey we create the screenshots folder for
@@ -152,11 +95,11 @@ export default class Runner extends EventEmitter {
   }
 
   async captureScreenshot(page: Driver['page'], step: Step) {
-    await page.waitForLoadState('load');
     const buffer = await page
       .screenshot({
         type: 'jpeg',
         quality: 80,
+        timeout: 5000,
       })
       .catch(() => {});
     /**
@@ -166,23 +109,50 @@ export default class Runner extends EventEmitter {
      */
     if (buffer) {
       const fileName = `${generateUniqueId()}.json`;
+      const screenshot: Screenshot = {
+        step,
+        timestamp: getTimestamp(),
+        data: buffer.toString('base64'),
+      };
       await writeFile(
         join(Runner.screenshotPath, fileName),
-        JSON.stringify({
-          step,
-          data: buffer.toString('base64'),
-        })
+        JSON.stringify(screenshot)
       );
     }
   }
 
+  get currentJourney() {
+    return this.#currentJourney;
+  }
+
   addHook(type: HookType, callback: HooksCallback) {
     this.hooks[type].push(callback);
   }
 
+  updateMonitor(config: MonitorConfig) {
+    if (!this.monitor) {
+      this.monitor = new Monitor(config);
+      return;
+    }
+    this.monitor.update(config);
+  }
+
   addJourney(journey: Journey) {
     this.journeys.push(journey);
-    this.currentJourney = journey;
+    this.#currentJourney = journey;
+  }
+
+  setReporter(options: RunOptions) {
+    /**
+     * Set up the corresponding reporter and fallback
+     * to default reporter if not provided
+     */
+    const { reporter, outfd } = options;
+    const Reporter =
+      typeof reporter === 'function'
+        ? reporter
+        : reporters[reporter] || reporters['default'];
+    this.#reporter = new Reporter({ fd: outfd });
   }
 
   async runBeforeAllHook(args: HooksArgs) {
@@ -214,7 +184,7 @@ export default class Runner extends EventEmitter {
       status: 'succeeded',
     };
     log(`Runner: start step (${step.name})`);
-    const { metrics, screenshots } = options;
+    const { metrics, screenshots, filmstrips, trace } = options;
     const { driver, pluginManager } = context;
     /**
      * URL needs to be the first navigation request of any step
@@ -225,22 +195,49 @@ export default class Runner extends EventEmitter {
       if (!data.url && req.isNavigationRequest()) {
         data.url = req.url();
       }
-      driver.page.off('request', captureUrl);
+      driver.context.off('request', captureUrl);
     };
-    driver.page.on('request', captureUrl);
+    driver.context.on('request', captureUrl);
+
     try {
+      /**
+       * Set up plugin manager context and also register
+       * step level plugins
+       */
+      const traceEnabled = trace || filmstrips;
       pluginManager.onStep(step);
+      traceEnabled && (await pluginManager.start('trace'));
+      // call the step definition
       await step.callback();
+      /**
+       * Collect all step level metrics
+       */
       if (metrics) {
-        data.metrics = await pluginManager.get(PerformanceManager).getMetrics();
+        data.pagemetrics = await (
+          pluginManager.get('performance') as PerformanceManager
+        ).getMetrics();
+      }
+      if (traceEnabled) {
+        const traceOutput = await pluginManager.stop('trace');
+        Object.assign(data, traceOutput);
       }
     } catch (error) {
       data.status = 'failed';
       data.error = error;
     } finally {
-      data.url ??= driver.page.url();
-      if (screenshots && screenshots !== 'off') {
-        await this.captureScreenshot(driver.page, step);
+      /**
+       * Capture screenshot for the newly created pages
+       * via popup or new windows/tabs
+       *
+       * Last open page will get us the correct screenshot
+       */
+      const pages = driver.context.pages();
+      const page = pages[pages.length - 1];
+      if (page) {
+        data.url ??= page.url();
+        if (screenshots && screenshots !== 'off') {
+          await this.captureScreenshot(page, step);
+        }
       }
     }
     log(`Runner: end step (${step.name})`);
@@ -256,7 +253,7 @@ export default class Runner extends EventEmitter {
     let skipStep = false;
     for (const step of journey.steps) {
       const start = monotonicTimeInSeconds();
-      this.emit('step:start', { journey, step });
+      this.#reporter?.onStepStart?.(journey, step);
       let data: StepResult = { status: 'succeeded' };
       if (skipStep) {
         data.status = 'skipped';
@@ -267,9 +264,7 @@ export default class Runner extends EventEmitter {
          */
         if (data.error) skipStep = true;
       }
-      this.emit('step:end', {
-        journey,
-        step,
+      this.#reporter?.onStepEnd?.(journey, step, {
         start,
         end: monotonicTimeInSeconds(),
         ...data,
@@ -283,12 +278,16 @@ export default class Runner extends EventEmitter {
   }
 
   registerJourney(journey: Journey, context: JourneyContext) {
-    this.currentJourney = journey;
+    this.#currentJourney = journey;
     const timestamp = getTimestamp();
     const { params } = context;
-    this.emit('journey:start', { journey, timestamp, params });
+    this.#reporter?.onJourneyStart?.(journey, {
+      timestamp,
+      params,
+    });
     /**
-     * Load and register the steps for the current journey
+     * Exeucute the journey callback which would
+     * register the steps for the current journey
      */
     journey.callback({ ...context.driver, params });
   }
@@ -298,25 +297,19 @@ export default class Runner extends EventEmitter {
     result: JourneyContext & JourneyResult,
     options: RunOptions
   ) {
+    const end = monotonicTimeInSeconds();
     const { pluginManager, start, status, error } = result;
     const pluginOutput = await pluginManager.output();
-    this.emit('journey:end', {
-      journey,
+    await this.#reporter?.onJourneyEnd?.(journey, {
       status,
       error,
       start,
-      end: monotonicTimeInSeconds(),
+      end,
+      timestamp: getTimestamp(),
       options,
       ...pluginOutput,
       browserconsole: status == 'failed' ? pluginOutput.browserconsole : [],
     });
-    /**
-     * Wait for the all the reported events to be consumed aschronously
-     * by reporter.
-     */
-    if (options.reporter === 'json') {
-      await once(this, 'journey:end:reported');
-    }
     // clear screenshots cache after each journey
     await rm(Runner.screenshotPath, { recursive: true, force: true });
   }
@@ -326,8 +319,7 @@ export default class Runner extends EventEmitter {
    */
   async runFakeJourney(journey: Journey, options: RunOptions) {
     const start = monotonicTimeInSeconds();
-    this.emit('journey:start', {
-      journey,
+    this.#reporter.onJourneyStart?.(journey, {
       timestamp: getTimestamp(),
       params: options.params,
     });
@@ -335,25 +327,20 @@ export default class Runner extends EventEmitter {
       status: 'failed',
       error: this.hookError,
     };
-    this.emit('journey:end', {
-      journey,
+    await this.#reporter.onJourneyEnd?.(journey, {
+      timestamp: getTimestamp(),
       start,
       options,
       end: monotonicTimeInSeconds(),
       ...result,
     });
-    if (options.reporter === 'json') {
-      await once(this, 'journey:end:reported');
-    }
     return result;
   }
 
   async runJourney(journey: Journey, options: RunOptions) {
-    const result: JourneyResult = {
-      status: 'succeeded',
-    };
-    log(`Runner: start journey (${journey.name})`);
+    const result: JourneyResult = { status: 'succeeded' };
     const context = await Runner.createContext(options);
+    log(`Runner: start journey (${journey.name})`);
     try {
       this.registerJourney(journey, context);
       const hookArgs = {
@@ -384,28 +371,56 @@ export default class Runner extends EventEmitter {
   }
 
   async init(options: RunOptions) {
-    const { reporter, outfd } = options;
-    /**
-     * Set up the corresponding reporter and fallback
-     */
-    const Reporter =
-      typeof reporter === 'function'
-        ? reporter
-        : reporters[reporter] || reporters['default'];
-    new Reporter(this, { fd: outfd });
-    this.emit('start', { numJourneys: this.journeys.length });
+    this.setReporter(options);
+    this.#reporter.onStart?.({
+      numJourneys: this.journeys.length,
+      networkConditions: options.networkConditions,
+    });
     /**
      * Set up the directory for caching screenshots
      */
     await mkdir(CACHE_PATH, { recursive: true });
   }
 
+  buildMonitors(options: RunOptions) {
+    /**
+     * Update the global monitor configuration required for
+     * setting defaults
+     */
+    this.updateMonitor({
+      throttling: options.throttling,
+      schedule: options.schedule,
+      locations: options.locations,
+      privateLocations: options.privateLocations,
+      params: options.params,
+      playwrightOptions: options.playwrightOptions,
+    });
+
+    const { match, tags } = options;
+    const monitors: Monitor[] = [];
+    for (const journey of this.journeys) {
+      if (!journey.isMatch(match, tags)) {
+        continue;
+      }
+      this.#currentJourney = journey;
+      /**
+       * Execute dummy callback to get all monitor specific
+       * configurations for the current journey
+       */
+      journey.callback({ params: options.params } as any);
+      journey.monitor.update(this.monitor?.config);
+      journey.monitor.validate();
+      monitors.push(journey.monitor);
+    }
+    return monitors;
+  }
+
   async run(options: RunOptions) {
     const result: RunResult = {};
-    if (this.active) {
+    if (this.#active) {
       return result;
     }
-    this.active = true;
+    this.#active = true;
     log(`Runner: run ${this.journeys.length} journeys`);
     this.init(options);
     await this.runBeforeAllHook({
@@ -419,7 +434,7 @@ export default class Runner extends EventEmitter {
        * Used by heartbeat to gather all registered journeys
        */
       if (dryRun) {
-        this.emit('journey:register', { journey });
+        this.#reporter.onJourneyRegister?.(journey);
         continue;
       }
       if (!journey.isMatch(match, tags)) {
@@ -440,14 +455,14 @@ export default class Runner extends EventEmitter {
   }
 
   async reset() {
+    this.#currentJourney = null;
+    this.journeys = [];
+    this.#active = false;
     /**
      * Clear all cache data stored for post processing by
      * the current synthetic agent run
      */
     await rm(CACHE_PATH, { recursive: true, force: true });
-    this.currentJourney = null;
-    this.journeys = [];
-    this.active = false;
-    this.emit('end', {});
+    await this.#reporter?.onEnd?.();
   }
 }

package/src/core/transform.ts

@@ -0,0 +1,160 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2020-present, Elastic NV
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+import { addHook } from 'pirates';
+import {
+  transformSync,
+  Loader,
+  CommonOptions,
+  TransformOptions,
+} from 'esbuild';
+import path from 'path';
+import sourceMapSupport from 'source-map-support';
+
+// Cache that holds the sourcemap content for each file
+const sourceMaps: Map<string, string> = new Map();
+
+// Register the source-map-support library to resolve the sourcemaps
+// for the files that are transpiled by esbuild
+/**
+ * Register the source-map-support library to resolve the sourcemaps
+ * for the files that are transpiled by esbuild and cache the sourcemaps
+ * for each file.
+ *
+ * Caching the sourcemap file is important, as it is used by the Synthetics agent
+ * to resolve the stack traces of journey, monitor and step functions.
+ */
+sourceMapSupport.install({
+  environment: 'node',
+  handleUncaughtExceptions: false,
+  retrieveSourceMap(source) {
+    if (!sourceMaps.has(source)) return null;
+    return {
+      map: JSON.parse(sourceMaps.get(source)),
+      url: source,
+    };
+  },
+});
+
+/**
+ * Default list of files and corresponding loaders we support
+ * while pushing project based monitors
+ */
+const LOADERS: Record<string, Loader> = {
+  '.ts': 'ts',
+  '.js': 'js',
+  '.mjs': 'js',
+  '.cjs': 'js',
+};
+
+const getLoader = (filename: string) => {
+  const ext = path.extname(filename);
+  return LOADERS[ext] || 'default';
+};
+
+export function commonOptions(): CommonOptions {
+  /**
+   * We are not minifying the code as we want it to be in sync with previous
+   * transformation phase and introduce it later.
+   */
+  return {
+    minify: false,
+    minifyIdentifiers: false,
+    minifySyntax: false,
+    minifyWhitespace: false,
+    sourcemap: 'both',
+    sourcesContent: false,
+    platform: 'node',
+    logLevel: 'silent',
+    format: 'cjs',
+    target: `node${process.version.slice(1)}`,
+  };
+}
+
+/**
+ * Transform the given code using esbuild and save the corresponding
+ * map file in memory to be retrived later.
+ */
+export function transform(
+  code: string,
+  filename: string,
+  options: TransformOptions = {}
+) {
+  const result = transformSync(code, {
+    ...commonOptions(),
+    sourcefile: filename,
+    loader: getLoader(filename),
+    /**
+     * Add this only for the transformation phase, using it on
+     * bundling phase would disable tree shaking and uncessary bloat
+     *
+     * Ensures backwards compatability with tsc's implicit strict behaviour
+     */
+    tsconfigRaw: {
+      compilerOptions: {
+        alwaysStrict: true,
+      },
+    },
+    ...options,
+  });
+
+  const warnings = result.warnings;
+  if (warnings && warnings.length > 0) {
+    for (const warning of warnings) {
+      console.log(warning.location);
+      console.log(warning.text);
+    }
+  }
+
+  /**
+   * Cache the sourcemap contents in memory, so we can look it up
+   * later when we try to resolve the sourcemap for a given file.
+   *
+   * Every time the synthetics agent is started, we register the source-map-support
+   * library to resolve the sourcemaps for the files that are transpiled by esbuild.
+   */
+  if (result.map) {
+    sourceMaps.set(filename, result.map);
+  }
+  return result;
+}
+
+/**
+ * Install the pirates hook to transform the code on the fly
+ * for all of the imported files.
+ */
+export function installTransform() {
+  const revertPirates = addHook(
+    (source: string, filename: string) => {
+      const { code } = transform(source, filename);
+      return code;
+    },
+    { exts: ['.ts', '.js', '.mjs', '.cjs'] }
+  );
+
+  return () => {
+    revertPirates();
+  };
+}