@elastic/synthetics 1.0.0-beta.3 → 1.0.0-beta.30

package/src/common_types.ts

@@ -23,25 +23,52 @@
  *
  */
 
-import { Protocol } from 'playwright-chromium/types/protocol';
+import {
+  BrowserContextOptions,
+  LaunchOptions,
+  CDPSession,
+  ChromiumBrowser,
+  ChromiumBrowserContext,
+  Page,
+} from 'playwright-chromium';
 import { Step } from './dsl';
-import { reporters } from './reporters';
+import { BuiltInReporterName, ReporterInstance } from './reporters';
+import { MonitorConfig } from './dsl/monitor';
 
 export type VoidCallback = () => void;
-export type Params = Record<string, unknown>;
+export type Location = {
+  file: string;
+  line: number;
+  column: number;
+};
+
+export type Params = Record<string, any>;
 export type HooksArgs = {
   env: string;
   params: Params;
 };
 export type HooksCallback = (args: HooksArgs) => void;
 export type StatusValue = 'succeeded' | 'failed' | 'skipped';
-export type Reporters = keyof typeof reporters;
+
+export type NetworkConditions = {
+  offline: boolean;
+  downloadThroughput: number;
+  uploadThroughput: number;
+  latency: number;
+};
+
+export type Driver = {
+  browser: ChromiumBrowser;
+  context: ChromiumBrowserContext;
+  page: Page;
+  client: CDPSession;
+};
 
 export type TraceOutput = {
   name: string;
   type: string;
   start: MetricDuration;
-  end?: MetricDuration;
+  duration?: MetricDuration;
   score?: number;
 };
 
@@ -73,26 +100,69 @@ export type BrowserInfo = {
   version: string;
 };
 
+export type Screenshot = {
+  timestamp: number;
+  step: Step;
+  data: string;
+};
+
+export type SecurityDetails = {
+  issuer?: string;
+  protocol?: string;
+  subjectName?: string;
+  validFrom?: number;
+  validTo?: number;
+};
+
+export type Request = {
+  method: string;
+  url: string;
+  headers: Record<string, string>;
+  // Total size in bytes of the request (body and headers)
+  bytes?: number;
+  body?: {
+    // Size in bytes of the request body
+    bytes: number;
+  };
+  referrer?: string;
+};
+
+export type Response = {
+  url?: string;
+  status: number;
+  statusText?: string;
+  mimeType?: string;
+  headers: Record<string, string>;
+  // Total size in bytes of the response (body and headers)
+  bytes?: number;
+  body?: {
+    // Size in bytes of the response body
+    bytes: number;
+  };
+  transferSize?: number;
+  redirectURL?: string;
+  securityDetails?: SecurityDetails;
+  remoteIPAddress?: string;
+  remotePort?: number;
+  fromServiceWorker?: boolean;
+};
+
 export type NetworkInfo = {
   url: string;
   browser: BrowserInfo;
-  method: string;
   type: string;
-  request: Protocol.Network.Request;
-  response?: Protocol.Network.Response;
+  request: Request;
+  response: Response;
   isNavigationRequest: boolean;
   requestSentTime: number;
   loadEndTime: number;
   responseReceivedTime: number;
-  status: number;
   resourceSize: number;
   transferSize: number;
-  timings?: {
+  timings: {
     blocked: number;
-    queueing: number;
     dns: number;
     ssl: number;
-    proxy: number;
     connect: number;
     send: number;
     wait: number;
@@ -101,9 +171,12 @@ export type NetworkInfo = {
   };
 } & DefaultPluginOutput;
 
+export type PageMetrics = Record<string, number>;
+
 export type BrowserMessage = {
   text: string;
   type: string;
+  error?: Error;
 } & DefaultPluginOutput;
 
 export type PluginOutput = {
@@ -114,30 +187,111 @@ export type PluginOutput = {
   metrics?: PerfMetrics;
 };
 
-export type CliArgs = {
-  capability?: Array<string>;
-  config?: string;
-  environment?: string;
-  outfd?: number;
-  headless?: boolean;
-  screenshots?: boolean;
-  ssblocks?: boolean;
-  metrics?: boolean;
-  filmstrips?: boolean;
-  trace?: boolean;
+export type ScreenshotOptions = 'on' | 'off' | 'only-on-failure';
+
+export type ThrottlingOptions = {
+  download?: number;
+  upload?: number;
+  latency?: number;
+};
+
+type BaseArgs = {
+  params?: Params;
+  screenshots?: ScreenshotOptions;
   dryRun?: boolean;
-  network?: boolean;
-  pauseOnError?: boolean;
-  reporter?: Reporters;
-  wsEndpoint?: string;
-  sandbox?: boolean;
-  json?: boolean;
-  pattern?: string;
-  inline: boolean;
   match?: string;
   tags?: Array<string>;
-  require: Array<string>;
-  debug?: boolean;
-  suiteParams?: string;
+  outfd?: number;
+  wsEndpoint?: string;
+  pauseOnError?: boolean;
+  ignoreHttpsErrors?: boolean;
+  playwrightOptions?: PlaywrightOptions;
+  quietExitCode?: boolean;
+  throttling?: ThrottlingOptions;
+  schedule?: MonitorConfig['schedule'];
+  locations?: MonitorConfig['locations'];
+};
+
+export type CliArgs = BaseArgs & {
+  config?: string;
+  reporter?: BuiltInReporterName;
+  pattern?: string;
+  inline?: boolean;
+  require?: Array<string>;
+  headless?: boolean;
+  sandbox?: boolean;
   richEvents?: boolean;
+  capability?: Array<string>;
+  ignoreHttpsErrors?: boolean;
+  throttling?: boolean | ThrottlingOptions;
+};
+
+export type RunOptions = BaseArgs & {
+  metrics?: boolean;
+  ssblocks?: boolean;
+  network?: boolean;
+  trace?: boolean;
+  filmstrips?: boolean;
+  environment?: string;
+  playwrightOptions?: PlaywrightOptions;
+  networkConditions?: NetworkConditions;
+  reporter?: BuiltInReporterName | ReporterInstance;
+};
+
+export type PushOptions = {
+  auth: string;
+  url: string;
+  project: string;
+  space: string;
+  schedule?: MonitorConfig['schedule'];
+  locations?: MonitorConfig['locations'];
+};
+
+export type PlaywrightOptions = LaunchOptions & BrowserContextOptions;
+export type SyntheticsConfig = {
+  params?: Params;
+  playwrightOptions?: PlaywrightOptions;
+  monitor?: MonitorConfig;
+};
+
+/** Runner Payload types */
+export type JourneyResult = {
+  status: StatusValue;
+  error?: Error;
+  networkinfo?: PluginOutput['networkinfo'];
+  browserconsole?: PluginOutput['browserconsole'];
+};
+
+export type StepResult = {
+  status: StatusValue;
+  url?: string;
+  error?: Error;
+  pagemetrics?: PageMetrics;
+  filmstrips?: PluginOutput['filmstrips'];
+  metrics?: PluginOutput['metrics'];
+  traces?: PluginOutput['traces'];
+};
+
+/** Reporter and Runner contract */
+export type StartEvent = {
+  numJourneys: number;
+  networkConditions?: NetworkConditions;
+};
+
+export type JourneyStartResult = {
+  timestamp: number;
+  params?: Params;
+};
+
+export type JourneyEndResult = JourneyStartResult &
+  JourneyResult & {
+    start: number;
+    end: number;
+    options: RunOptions;
+    timestamp: number;
+  };
+
+export type StepEndResult = StepResult & {
+  start: number;
+  end: number;
 };

package/src/config.ts

@@ -24,13 +24,10 @@
  */
 
 import { isAbsolute, resolve, dirname } from 'path';
+import { SyntheticsConfig } from './common_types';
 import { isFile } from './helpers';
 
-interface Config {
-  params?: Record<string, unknown>;
-}
-
-export function readConfig(env: string, config?: string): Config {
+export function readConfig(env: string, config?: string): SyntheticsConfig {
   let options = {};
   const cwd = process.cwd();
   /**

package/src/core/gatherer.ts

@@ -23,23 +23,10 @@
  *
  */
 
-import {
-  CDPSession,
-  chromium,
-  ChromiumBrowser,
-  ChromiumBrowserContext,
-  Page,
-} from 'playwright-chromium';
+import { chromium, ChromiumBrowser, BrowserContext } from 'playwright-chromium';
 import { PluginManager } from '../plugins';
-import { RunOptions } from './runner';
 import { log } from './logger';
-
-export type Driver = {
-  browser: ChromiumBrowser;
-  context: ChromiumBrowserContext;
-  page: Page;
-  client: CDPSession;
-};
+import { Driver, NetworkConditions, RunOptions } from '../common_types';
 
 /**
  * Purpose of the Gatherer is to set up the necessary browser driver
@@ -49,38 +36,79 @@ export class Gatherer {
   static browser: ChromiumBrowser;
 
   static async setupDriver(options: RunOptions): Promise<Driver> {
+    log('Gatherer: setup driver');
+    const { wsEndpoint, playwrightOptions, networkConditions } = options;
+
     if (Gatherer.browser == null) {
-      const { wsEndpoint, headless, sandbox = false } = options;
       if (wsEndpoint) {
         log(`Gatherer: connecting to WS endpoint: ${wsEndpoint}`);
-        Gatherer.browser = await chromium.connect({ wsEndpoint });
+        Gatherer.browser = await chromium.connect(wsEndpoint);
       } else {
         Gatherer.browser = await chromium.launch({
-          headless,
-          chromiumSandbox: sandbox,
+          ...playwrightOptions,
+          args: [
+            ...(playwrightOptions?.headless ? ['--disable-gpu'] : []),
+            ...(playwrightOptions?.args ?? []),
+          ],
         });
       }
     }
-    const context = await Gatherer.browser.newContext();
+    const context = await Gatherer.browser.newContext({
+      ...playwrightOptions,
+      userAgent: await Gatherer.getUserAgent(playwrightOptions?.userAgent),
+    });
+    Gatherer.setNetworkConditions(context, networkConditions);
+
     const page = await context.newPage();
     const client = await context.newCDPSession(page);
     return { browser: Gatherer.browser, context, page, client };
   }
 
+  static async getUserAgent(userAgent?: string) {
+    if (!userAgent) {
+      const session = await Gatherer.browser.newBrowserCDPSession();
+      ({ userAgent } = await session.send('Browser.getVersion'));
+      return userAgent + ' Elastic/Synthetics';
+    }
+    return userAgent;
+  }
+
+  static setNetworkConditions(
+    context: BrowserContext,
+    networkConditions: NetworkConditions
+  ) {
+    if (networkConditions) {
+      context.on('page', page => {
+        const context = page.context();
+        const emulatePromise = context
+          .newCDPSession(page)
+          .then(client =>
+            client.send('Network.emulateNetworkConditions', networkConditions)
+          );
+        /**
+         * Guard against pages that gets closed before the emulation kicks to capture
+         * unhandled rejections from accessing the CDP session of closed page
+         */
+        Promise.race([
+          new Promise<void>(resolve => page.on('close', () => resolve())),
+          emulatePromise,
+        ]);
+      });
+    }
+  }
+
   /**
    * Starts recording all events related to the v8 devtools protocol
    * https://chromedevtools.github.io/devtools-protocol/v8/
    */
   static async beginRecording(driver: Driver, options: RunOptions) {
     log('Gatherer: started recording');
-    const { filmstrips, trace, network, metrics } = options;
+    const { network, metrics } = options;
     const pluginManager = new PluginManager(driver);
-    const plugins = [pluginManager.start('browserconsole')];
-    network && plugins.push(pluginManager.start('network'));
-    metrics && plugins.push(pluginManager.start('performance'));
-    if (filmstrips || trace) {
-      plugins.push(pluginManager.start('trace', { filmstrips, trace }));
-    }
+    pluginManager.registerAll(options);
+    const plugins = [await pluginManager.start('browserconsole')];
+    network && plugins.push(await pluginManager.start('network'));
+    metrics && plugins.push(await pluginManager.start('performance'));
     await Promise.all(plugins);
     return pluginManager;
   }

package/src/core/index.ts

@@ -25,8 +25,10 @@
 
 import { Journey, JourneyCallback, JourneyOptions } from '../dsl';
 import Runner from './runner';
-import { VoidCallback, HooksCallback } from '../common_types';
+import { VoidCallback, HooksCallback, Location } from '../common_types';
+import { wrapFnWithLocation } from '../helpers';
 import { log } from './logger';
+import { MonitorConfig } from '../dsl/monitor';
 
 /**
  * Use a gloabl Runner which would be accessed by the runtime and
@@ -39,22 +41,41 @@ if (!global[SYNTHETICS_RUNNER]) {
 
 export const runner: Runner = global[SYNTHETICS_RUNNER];
 
-export const journey = (
-  options: JourneyOptions | string,
-  callback: JourneyCallback
-) => {
-  log(`register journey: ${options}`);
-  if (typeof options === 'string') {
-    options = { name: options, id: options };
+export const journey = wrapFnWithLocation(
+  (
+    location: Location,
+    options: JourneyOptions | string,
+    callback: JourneyCallback
+  ) => {
+    log(`register journey: ${JSON.stringify(options)}`);
+    if (typeof options === 'string') {
+      options = { name: options, id: options };
+    }
+    const j = new Journey(options, callback, location);
+    runner.addJourney(j);
+    return j;
   }
-  const j = new Journey(options, callback);
-  runner.addJourney(j);
-  return j;
-};
+);
+
+export const step = wrapFnWithLocation(
+  (location: Location, name: string, callback: VoidCallback) => {
+    log(`register step: ${name}`);
+    return runner.currentJourney?.addStep(name, callback, location);
+  }
+);
 
-export const step = (name: string, callback: VoidCallback) => {
-  log(`register step: ${name}`);
-  return runner.currentJourney?.addStep(name, callback);
+export const monitor = {
+  use: wrapFnWithLocation((location: Location, config: MonitorConfig) => {
+    /**
+     * If the context is inside journey, then set it to journey context
+     * otherwise set to the global monitor which will be used for all journeys
+     */
+    if (runner.currentJourney) {
+      runner.currentJourney.updateMonitor(config);
+    } else {
+      runner.updateMonitor(config);
+    }
+  }),
 };
 
 export const beforeAll = (callback: HooksCallback) => {

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');
 }