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

package/src/loader.ts

@@ -0,0 +1,167 @@
+/**
+ * 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 { stdin, cwd } from 'process';
+import { resolve } from 'path';
+import { CliArgs } from './common_types';
+import { step, journey } from './core';
+import { log } from './core/logger';
+import { expect } from './core/expect';
+import {
+  isDepInstalled,
+  isDirectory,
+  totalist,
+  findPkgJsonByTraversing,
+} from './helpers';
+import { installTransform } from './core/transform';
+
+const resolvedCwd = cwd();
+
+/**
+ * Perform global setup process required for running the test suites
+ * and also for bundling the monitors. The process includes
+ * - Transpiling the TS/JS test files
+ * - Loading these files for running test suites
+ */
+export async function globalSetup(options: CliArgs, args: string[]) {
+  const revert = installTransform();
+  await loadTestFiles(options, args);
+  return () => {
+    revert();
+  };
+}
+
+export async function loadTestFiles(options: CliArgs, args: string[]) {
+  /**
+   * Preload modules before running the tests
+   */
+  const modules = [].concat(options.require || []).filter(Boolean);
+  for (const name of modules) {
+    if (isDepInstalled(name)) {
+      require(name);
+    } else {
+      throw new Error(`cannot find module '${name}'`);
+    }
+  }
+
+  if (options.inline) {
+    const source = await readStdin();
+    loadInlineScript(source);
+    return;
+  }
+  /**
+   * Handle piped files by reading the STDIN
+   * ex: ls example/suites/*.js | npx @elastic/synthetics
+   */
+  const files =
+    args.length > 0 ? args : (await readStdin()).split('\n').filter(Boolean);
+  const suites = await prepareSuites(files, options.pattern);
+  requireSuites(suites);
+}
+
+const loadInlineScript = source => {
+  const scriptFn = new Function(
+    'step',
+    'page',
+    'context',
+    'browser',
+    'params',
+    'expect',
+    'request',
+    source
+  );
+  journey('inline', ({ page, context, browser, params, request }) => {
+    scriptFn.apply(null, [
+      step,
+      page,
+      context,
+      browser,
+      params,
+      expect,
+      request,
+    ]);
+  });
+};
+
+/**
+ * Read the input from STDIN and run it as inline journey
+ */
+async function readStdin() {
+  const chunks = [];
+  stdin.resume();
+  stdin.setEncoding('utf-8');
+  for await (const chunk of stdin) {
+    chunks.push(chunk);
+  }
+  return chunks.join();
+}
+
+function requireSuites(suites: Iterable<string>) {
+  for (const suite of suites) {
+    require(suite);
+  }
+}
+
+/**
+ * Handle both directory and files that are passed through TTY
+ * and add them to suites
+ */
+async function prepareSuites(inputs: string[], filePattern?: string) {
+  const suites = new Set<string>();
+  const addSuite = absPath => {
+    log(`Processing file: ${absPath}`);
+    suites.add(require.resolve(absPath));
+  };
+  /**
+   * Match all files inside the directory with the
+   * .journey.{mjs|cjs|js|ts) extensions
+   */
+  const pattern = filePattern
+    ? new RegExp(filePattern, 'i')
+    : /.+\.journey\.([mc]js|[jt]s?)$/;
+  /**
+   * Ignore node_modules by default when running suites
+   */
+  const ignored = /node_modules/i;
+
+  for (const input of inputs) {
+    const absPath = resolve(resolvedCwd, input);
+    /**
+     * Validate for package.json file before running
+     * the suites
+     */
+    findPkgJsonByTraversing(absPath, resolvedCwd);
+    if (isDirectory(absPath)) {
+      await totalist(absPath, (rel, abs) => {
+        if (pattern.test(rel) && !ignored.test(rel)) {
+          addSuite(abs);
+        }
+      });
+    } else {
+      addSuite(absPath);
+    }
+  }
+  return suites.values();
+}

package/src/locations/index.ts

@@ -0,0 +1,95 @@
+/**
+ * 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 { sendReqAndHandleError } from '../push/request';
+import { indent, write } from '../helpers';
+import { generateURL } from '../push/utils';
+
+export type LocationCmdOptions = {
+  auth: string;
+  url: string;
+};
+
+type LocationMetadata = {
+  id: string;
+  label: string;
+  isServiceManaged: boolean;
+};
+
+export type LocationAPIResponse = {
+  locations: Array<LocationMetadata>;
+};
+
+const PRIVATE_KEYWORD = '(private)';
+
+export async function getLocations(options: LocationCmdOptions) {
+  const resp = await sendReqAndHandleError<LocationAPIResponse>({
+    url: generateURL(options, 'location'),
+    method: 'GET',
+    auth: options.auth,
+  });
+  return resp.locations;
+}
+
+export function formatLocations(locations: Array<LocationMetadata>) {
+  const formatted: Array<string> = [];
+  for (const location of locations) {
+    let name = location.label;
+    if (location.isServiceManaged) {
+      [, name] = name.includes('-') ? name.split('-') : [, name];
+      name = name.toLowerCase().trim().split(' ').join('_');
+    } else {
+      name = `${name}${PRIVATE_KEYWORD}`;
+    }
+    formatted.push(name);
+  }
+  return formatted;
+}
+
+export function groupLocations(locations: Array<string>) {
+  const grouped = { locations: [], privateLocations: [] };
+  for (const loc of locations) {
+    if (loc.includes(PRIVATE_KEYWORD)) {
+      grouped.privateLocations.push(loc.replace(PRIVATE_KEYWORD, ''));
+    } else {
+      grouped.locations.push(loc);
+    }
+  }
+  return grouped;
+}
+
+export function renderLocations(locations: Array<string>) {
+  let outer = 'Available locations: \n';
+  let inner = '';
+  for (const location of locations) {
+    inner += `* ${location}\n`;
+  }
+  outer += indent(inner);
+  outer += `\nSet default location for monitors via
+  - Synthetics config file 'monitors.locations' | 'monitors.privateLocations' field
+  - Monitor API 'monitor.use({ locations: ["japan"], privateLocations: ["custom-location"] }')`;
+
+  write(outer);
+}

package/src/{reporters/reporter.ts → locations/public-locations.ts}

@@ -23,13 +23,16 @@
  *
  */
 
-import Runner from '../core/runner';
-
-export type ReporterOptions = {
-  fd?: number;
-  colors?: boolean;
+// DO NOT EDIT - UPDATE WITH `npm run build:locations`
+export const LocationsMap = {
+  japan: 'asia-northeast1-a',
+  india: 'asia-south1-a',
+  singapore: 'asia-southeast1-a',
+  australia_east: 'australia-southeast1-a',
+  united_kingdom: 'europe-west2-a',
+  germany: 'europe-west3-a',
+  canada_east: 'northamerica-northeast1-a',
+  brazil: 'southamerica-east1-a',
+  us_east: 'us-east4-a',
+  us_west: 'us-west1-a',
 };
-
-export default interface Reporter {
-  new (runner: Runner, options: ReporterOptions): any;
-}

package/src/options.ts

@@ -0,0 +1,227 @@
+/**
+ * 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 merge from 'deepmerge';
+import { createOption } from 'commander';
+import { readConfig } from './config';
+import { getNetworkConditions, DEFAULT_THROTTLING_OPTIONS } from './helpers';
+import type { CliArgs, RunOptions, ThrottlingOptions } from './common_types';
+
+/**
+ * Set debug based on DEBUG ENV and -d flags
+ * namespace - synthetics
+ */
+const namespace = 'synthetics';
+if (process.env.DEBUG && process.env.DEBUG.includes(namespace)) {
+  process.env.DEBUG = '1';
+}
+
+export function normalizeOptions(cliArgs: CliArgs): RunOptions {
+  const options: RunOptions = {
+    ...cliArgs,
+    environment: process.env['NODE_ENV'] || 'development',
+  };
+  /**
+   * Group all events that can be consumed by heartbeat and
+   * eventually by the Synthetics UI.
+   */
+  if (cliArgs.richEvents) {
+    options.reporter = cliArgs.reporter ?? 'json';
+    options.ssblocks = true;
+    options.network = true;
+    options.trace = true;
+    options.quietExitCode = true;
+  }
+
+  if (cliArgs.capability) {
+    const supportedCapabilities = [
+      'trace',
+      'network',
+      'filmstrips',
+      'metrics',
+      'ssblocks',
+    ];
+    /**
+     * trace - record chrome trace events(LCP, FCP, CLS, etc.) for all journeys
+     * network - capture network information for all journeys
+     * filmstrips - record detailed filmstrips for all journeys
+     * metrics - capture performance metrics (DOM Nodes, Heap size, etc.) for each step
+     * ssblocks - Dedupes the screenshots in to blocks to save storage space
+     */
+    for (const flag of cliArgs.capability) {
+      if (supportedCapabilities.includes(flag)) {
+        options[flag] = true;
+      } else {
+        console.warn(
+          `Missing capability "${flag}", current supported capabilities are ${supportedCapabilities.join(
+            ', '
+          )}`
+        );
+      }
+    }
+  }
+
+  /**
+   * Validate and read synthetics config file
+   * based on the environment
+   */
+  const config =
+    cliArgs.config || !cliArgs.inline
+      ? readConfig(options.environment, cliArgs.config)
+      : {};
+
+  /**
+   * Order of preference for options that are used while running are
+   * 1. Local options configured via Runner API
+   * 2. CLI flags
+   * 3. Configuration file
+   */
+  options.params = Object.freeze(merge(config.params, cliArgs.params || {}));
+
+  /**
+   * Merge playwright options from CLI and Synthetics config
+   * and prefer individual options over other option
+   */
+  const playwrightOpts = merge(
+    config.playwrightOptions,
+    cliArgs.playwrightOptions || {}
+  );
+  options.playwrightOptions = {
+    ...playwrightOpts,
+    headless: cliArgs.headless,
+    chromiumSandbox: cliArgs.sandbox ?? playwrightOpts?.chromiumSandbox,
+    ignoreHTTPSErrors:
+      cliArgs.ignoreHttpsErrors ?? playwrightOpts?.ignoreHTTPSErrors,
+  };
+
+  /**
+   * Get the default monitor config from synthetics.config.ts file
+   */
+  const monitor = config.monitor;
+  if (cliArgs.throttling) {
+    const throttleConfig = merge.all([
+      DEFAULT_THROTTLING_OPTIONS,
+      toObject(monitor?.throttling),
+      toObject(cliArgs.throttling),
+    ]);
+    if (monitor?.throttling !== false) {
+      options.throttling = throttleConfig;
+      options.networkConditions = getNetworkConditions(throttleConfig);
+    } else {
+      /**
+       * If the throttling is disabled via Project monitor config, use it a source
+       * of truth and disable it for pushing those monitors.
+       */
+      options.throttling = false;
+    }
+  } else {
+    /**
+     * Do not apply throttling when `--no-throttling` flag is passed
+     */
+    options.throttling = false;
+  }
+
+  options.schedule = cliArgs.schedule ?? monitor?.schedule;
+  options.locations = cliArgs.locations ?? monitor?.locations;
+  options.privateLocations =
+    cliArgs.privateLocations ?? monitor?.privateLocations;
+
+  return options;
+}
+
+function toObject(value: boolean | Record<string, any>): Record<string, any> {
+  const defaulVal = {};
+  if (typeof value === 'boolean') {
+    return defaulVal;
+  }
+  return value || defaulVal;
+}
+
+/**
+ * Parses the throttling CLI settings and also
+ * adapts to the format to keep the backwards compatability
+ * - Accepts old format `<5d/3u/20l>`
+ * - Processess new format otherwise `{download: 5, upload: 3, latency: 20}`
+ */
+export function parseThrottling(value: string, prev?: string) {
+  const THROTTLING_REGEX = /([0-9]{1,}u)|([0-9]{1,}d)|([0-9]{1,}l)/gm;
+  if (THROTTLING_REGEX.test(value)) {
+    const throttling: ThrottlingOptions = {};
+    const conditions = value.split('/');
+
+    conditions.forEach(condition => {
+      const setting = condition.slice(0, condition.length - 1);
+      const token = condition.slice(-1);
+      switch (token) {
+        case 'd':
+          throttling.download = Number(setting);
+          break;
+        case 'u':
+          throttling.upload = Number(setting);
+          break;
+        case 'l':
+          throttling.latency = Number(setting);
+          break;
+      }
+    });
+    return throttling;
+  }
+  return JSON.parse(value || prev);
+}
+
+export function getCommonCommandOpts() {
+  const params = createOption(
+    '-p, --params <jsonstring>',
+    'JSON object that gets injected to all journeys'
+  );
+  params.argParser(JSON.parse);
+
+  const playwrightOpts = createOption(
+    '--playwright-options <jsonstring>',
+    'JSON object to pass in custom Playwright options for the agent. Options passed will be merged with Playwright options defined in your synthetics.config.js file.'
+  );
+  playwrightOpts.argParser(JSON.parse);
+
+  const pattern = createOption(
+    '--pattern <pattern>',
+    'RegExp pattern to look for journey files that are different from the default (ex: /*.journey.(ts|js)$/)'
+  );
+  const tags = createOption(
+    '--tags <name...>',
+    'run only journeys with a tag that matches the glob'
+  );
+  const match = createOption(
+    '--match <name>',
+    'run only journeys with a name or tag that matches the glob'
+  );
+
+  return {
+    params,
+    playwrightOpts,
+    pattern,
+    tags,
+    match,
+  };
+}

package/src/plugins/browser-console.ts

@@ -23,8 +23,7 @@
  *
  */
 
-import { Page } from 'playwright-chromium';
-import { BrowserMessage } from '../common_types';
+import { BrowserMessage, Driver } from '../common_types';
 import { Step } from '../dsl';
 import { getTimestamp } from '../helpers';
 
@@ -34,6 +33,8 @@ export class BrowserConsole {
   private messages: BrowserMessage[] = [];
   _currentStep: Partial<Step> = null;
 
+  constructor(private driver: Driver) {}
+
   private consoleEventListener = msg => {
     if (!this._currentStep) {
       return;
@@ -47,20 +48,41 @@ export class BrowserConsole {
         type,
         step: { name, index },
       });
-      if (this.messages.length > defaultMessageLimit) {
-        this.messages.splice(0, 1);
-      }
+
+      this.enforceMessagesLimit();
+    }
+  };
+
+  private pageErrorEventListener = (error: Error) => {
+    if (!this._currentStep) {
+      return;
     }
+    const { name, index } = this._currentStep;
+    this.messages.push({
+      timestamp: getTimestamp(),
+      text: error.message,
+      type: 'error',
+      step: { name, index },
+      error,
+    });
+
+    this.enforceMessagesLimit();
   };
 
-  constructor(private page: Page) {}
+  private enforceMessagesLimit() {
+    if (this.messages.length > defaultMessageLimit) {
+      this.messages.splice(0, 1);
+    }
+  }
 
   start() {
-    this.page.on('console', this.consoleEventListener);
+    this.driver.page.on('console', this.consoleEventListener);
+    this.driver.page.on('pageerror', this.pageErrorEventListener);
   }
 
   stop() {
-    this.page.off('console', this.consoleEventListener);
+    this.driver.page.off('console', this.consoleEventListener);
+    this.driver.page.off('pageerror', this.pageErrorEventListener);
     return this.messages;
   }
 }