@elastic/synthetics 1.0.0-beta.25 → 1.0.0-beta.26

package/src/reporters/json.ts

@@ -47,8 +47,12 @@ import {
   PerfMetrics,
   Params,
   Screenshot,
+  StartEvent,
+  JourneyStartResult,
+  StepEndResult,
+  JourneyEndResult,
+  PageMetrics,
 } from '../common_types';
-import { PageMetrics } from '../plugins';
 
 /* eslint-disable @typescript-eslint/no-var-requires */
 const { version, name } = require('../../package.json');
@@ -296,179 +300,183 @@ export async function gatherScreenshots(
 }
 
 export default class JSONReporter extends BaseReporter {
-  override _registerListeners() {
+  onStart(params: StartEvent) {
     /**
      * report the number of journeys that exists on a suite which
      * could be used for better sharding
      */
-    this.runner.on('start', ({ numJourneys, networkConditions }) => {
-      this.writeJSON({
-        type: 'synthetics/metadata',
-        root_fields: {
-          num_journeys: numJourneys,
-        },
-        payload: networkConditions
-          ? {
-              network_conditions: networkConditions,
-            }
-          : undefined,
-      });
+    this.writeJSON({
+      type: 'synthetics/metadata',
+      root_fields: {
+        num_journeys: params.numJourneys,
+      },
+      payload: params.networkConditions
+        ? {
+            network_conditions: params.networkConditions,
+          }
+        : undefined,
     });
+  }
 
-    this.runner.on('journey:register', ({ journey }) => {
-      this.writeJSON({
-        type: 'journey/register',
-        journey,
-      });
+  onJourneyRegister(journey: Journey): void {
+    this.writeJSON({
+      type: 'journey/register',
+      journey,
     });
+  }
 
-    this.runner.on('journey:start', ({ journey, timestamp, params }) => {
-      this.writeJSON({
-        type: 'journey/start',
-        journey,
-        timestamp,
-        payload: { params, source: journey.callback.toString() },
-      });
+  override onJourneyStart(
+    journey: Journey,
+    { timestamp, params }: JourneyStartResult
+  ) {
+    this.writeJSON({
+      type: 'journey/start',
+      journey,
+      timestamp,
+      payload: { params, source: journey.callback.toString() },
     });
+  }
 
-    this.runner.on(
-      'step:end',
-      ({
-        journey,
-        step,
-        start,
-        end,
-        error,
-        url,
-        status,
-        pagemetrics,
-        traces,
-        metrics,
-        filmstrips,
-      }) => {
-        this.writeMetrics(journey, step, 'relative_trace', traces);
-        this.writeMetrics(journey, step, 'experience', metrics);
-        if (filmstrips) {
-          // Write each filmstrip separately so that we don't get documents that are too large
-          filmstrips.forEach((strip, index) => {
-            this.writeJSON({
-              type: 'step/filmstrips',
-              journey,
-              step,
-              payload: { index },
-              root_fields: {
-                browser: { relative_trace: { start: strip.start } },
-              },
-              blob: strip.blob,
-              blob_mime: strip.mime,
-            });
-          });
-        }
+  override onStepEnd(
+    journey: Journey,
+    step: Step,
+    {
+      start,
+      end,
+      error,
+      url,
+      status,
+      pagemetrics,
+      traces,
+      metrics,
+      filmstrips,
+    }: StepEndResult
+  ) {
+    this.writeMetrics(journey, step, 'relative_trace', traces);
+    this.writeMetrics(journey, step, 'experience', metrics);
+    if (filmstrips) {
+      // Write each filmstrip separately so that we don't get documents that are too large
+      filmstrips.forEach((strip, index) => {
         this.writeJSON({
-          type: 'step/end',
+          type: 'step/filmstrips',
           journey,
-          step: {
-            ...step,
-            duration: {
-              us: getDurationInUs(end - start),
-            },
-          },
-          url,
-          error,
-          payload: {
-            source: step.callback.toString(),
-            url,
-            status,
-            pagemetrics,
+          step,
+          payload: { index },
+          root_fields: {
+            browser: { relative_trace: { start: strip.start } },
           },
+          blob: strip.blob,
+          blob_mime: strip.mime,
         });
-      }
-    );
+      });
+    }
 
-    this.runner.on(
-      'journey:end',
-      async ({
-        journey,
-        timestamp,
-        start,
-        end,
-        networkinfo,
-        browserconsole,
+    this.writeJSON({
+      type: 'step/end',
+      journey,
+      step: {
+        ...step,
+        duration: {
+          us: getDurationInUs(end - start),
+        },
+      },
+      url,
+      error,
+      payload: {
+        source: step.callback.toString(),
+        url,
         status,
-        error,
-        options,
-      }) => {
-        const { ssblocks, screenshots } = options;
-        const writeScreenshots =
-          screenshots === 'on' ||
-          (screenshots === 'only-on-failure' && status === 'failed');
-        if (writeScreenshots) {
-          await gatherScreenshots(
-            join(CACHE_PATH, 'screenshots'),
-            async screenshot => {
-              const { data, timestamp, step } = screenshot;
-              if (!data) {
-                return;
-              }
-              if (ssblocks) {
-                await this.writeScreenshotBlocks(journey, screenshot);
-              } else {
-                this.writeJSON({
-                  type: 'step/screenshot',
-                  timestamp,
-                  journey,
-                  step,
-                  blob: data,
-                  blob_mime: 'image/jpeg',
-                });
-              }
-            }
-          );
-        }
+        pagemetrics,
+      },
+    });
+  }
 
-        if (networkinfo) {
-          networkinfo.forEach(ni => {
-            const { ecs, payload } = formatNetworkFields(ni);
-            this.writeJSON({
-              type: 'journey/network_info',
-              journey,
-              timestamp: ni.timestamp,
-              root_fields: snakeCaseKeys(ecs),
-              step: ni.step,
-              payload: snakeCaseKeys(payload),
-            });
-          });
-        }
-        if (browserconsole) {
-          browserconsole.forEach(({ timestamp, text, type, step, error }) => {
+  override async onJourneyEnd(
+    journey: Journey,
+    {
+      timestamp,
+      start,
+      end,
+      networkinfo,
+      browserconsole,
+      status,
+      error,
+      options,
+    }: JourneyEndResult
+  ) {
+    const { ssblocks, screenshots } = options;
+    const writeScreenshots =
+      screenshots === 'on' ||
+      (screenshots === 'only-on-failure' && status === 'failed');
+    if (writeScreenshots) {
+      await gatherScreenshots(
+        join(CACHE_PATH, 'screenshots'),
+        async screenshot => {
+          const { data, timestamp, step } = screenshot;
+          if (!data) {
+            return;
+          }
+          if (ssblocks) {
+            await this.writeScreenshotBlocks(journey, screenshot);
+          } else {
             this.writeJSON({
-              type: 'journey/browserconsole',
-              journey,
+              type: 'step/screenshot',
               timestamp,
+              journey,
               step,
-              error,
-              payload: {
-                text,
-                type,
-              } as Payload,
+              blob: data,
+              blob_mime: 'image/jpeg',
             });
-          });
+          }
         }
+      );
+    }
 
+    if (networkinfo) {
+      networkinfo.forEach(ni => {
+        const { ecs, payload } = formatNetworkFields(ni);
         this.writeJSON({
-          type: 'journey/end',
+          type: 'journey/network_info',
+          journey,
+          timestamp: ni.timestamp,
+          root_fields: snakeCaseKeys(ecs),
+          step: ni.step,
+          payload: snakeCaseKeys(payload),
+        });
+      });
+    }
+
+    if (browserconsole) {
+      browserconsole.forEach(({ timestamp, text, type, step, error }) => {
+        this.writeJSON({
+          type: 'journey/browserconsole',
           journey,
           timestamp,
+          step,
           error,
           payload: {
-            start,
-            end,
-            status,
-          },
+            text,
+            type,
+          } as Payload,
         });
-        process.nextTick(() => this.runner.emit('journey:end:reported', {}));
-      }
-    );
+      });
+    }
+
+    this.writeJSON({
+      type: 'journey/end',
+      journey,
+      timestamp,
+      error,
+      payload: {
+        start,
+        end,
+        status,
+      },
+    });
+  }
+
+  override onEnd() {
+    this.stream.flushSync();
   }
 
   async writeScreenshotBlocks(journey: Journey, screenshot: Screenshot) {

package/src/reporters/junit.ts

@@ -23,8 +23,14 @@
  *
  */
 
-import { mkdirSync, writeFileSync } from 'fs';
+import { mkdir, writeFile } from 'fs/promises';
 import { dirname } from 'path';
+import {
+  JourneyEndResult,
+  JourneyStartResult,
+  StepEndResult,
+} from '../common_types';
+import { Journey, Step } from '../dsl';
 import { formatError, indent, now } from '../helpers';
 import BaseReporter from './base';
 
@@ -51,104 +57,103 @@ export default class JUnitReporter extends BaseReporter {
   private totalTests = 0;
   private totalFailures = 0;
   private totalSkipped = 0;
+  #journeyMap = new Map<string, XMLEntry>();
 
-  override _registerListeners() {
-    const journeyMap = new Map<string, XMLEntry>();
+  override onJourneyStart(journey: Journey, {}: JourneyStartResult) {
+    if (!this.#journeyMap.has(journey.name)) {
+      const entry = {
+        name: 'testsuite',
+        attributes: {
+          name: journey.name,
+          tests: 0,
+          failures: 0,
+          skipped: 0,
+          errors: 0,
+        },
+        children: [],
+      };
+      this.#journeyMap.set(journey.name, entry);
+    }
+  }
 
-    this.runner.on('journey:start', ({ journey }) => {
-      if (!journeyMap.has(journey.name)) {
-        const entry = {
-          name: 'testsuite',
-          attributes: {
-            name: journey.name,
-            tests: 0,
-            failures: 0,
-            skipped: 0,
-            errors: 0,
-          },
-          children: [],
-        };
-        journeyMap.set(journey.name, entry);
-      }
-    });
+  override onStepEnd(
+    journey: Journey,
+    step: Step,
+    { status, error, start, end }: StepEndResult
+  ) {
+    if (!this.#journeyMap.has(journey.name)) {
+      return;
+    }
+    const entry = this.#journeyMap.get(journey.name);
+    const caseEntry = {
+      name: 'testcase',
+      attributes: {
+        name: step.name,
+        classname: journey.name + ' ' + step.name,
+        time: end - start,
+      },
+      children: [],
+    };
 
-    this.runner.on(
-      'step:end',
-      ({ journey, step, status, error, start, end }) => {
-        if (!journeyMap.has(journey.name)) {
-          return;
-        }
-        const entry = journeyMap.get(journey.name);
-        const caseEntry = {
-          name: 'testcase',
-          attributes: {
-            name: step.name,
-            classname: journey.name + ' ' + step.name,
-            time: end - start,
-          },
-          children: [],
-        };
+    entry.attributes.tests++;
+    if (status === 'failed') {
+      const { name, message, stack } = formatError(error);
+      caseEntry.children.push({
+        name: 'failure',
+        attributes: {
+          message,
+          type: name,
+        },
+        text: stack,
+      });
+      entry.attributes.failures++;
+    } else if (status === 'skipped') {
+      caseEntry.children.push({
+        name: 'skipped',
+        attributes: {
+          message: 'previous step failed',
+        },
+      });
+      entry.attributes.skipped++;
+    }
+    entry.children.push(caseEntry);
+  }
 
-        entry.attributes.tests++;
-        if (status === 'failed') {
-          const { name, message, stack } = formatError(error);
-          caseEntry.children.push({
-            name: 'failure',
-            attributes: {
-              message,
-              type: name,
-            },
-            text: stack,
-          });
-          entry.attributes.failures++;
-        } else if (status === 'skipped') {
-          caseEntry.children.push({
-            name: 'skipped',
-            attributes: {
-              message: 'previous step failed',
-            },
-          });
-          entry.attributes.skipped++;
-        }
-        entry.children.push(caseEntry);
-      }
-    );
+  override onJourneyEnd(journey: Journey, {}: JourneyEndResult) {
+    if (!this.#journeyMap.has(journey.name)) {
+      return;
+    }
+    const { attributes } = this.#journeyMap.get(journey.name);
+    this.totalTests += attributes.tests;
+    this.totalFailures += attributes.failures;
+    this.totalSkipped += attributes.skipped;
+  }
 
-    this.runner.on('journey:end', ({ journey }) => {
-      if (!journeyMap.has(journey.name)) {
-        return;
-      }
-      const { attributes } = journeyMap.get(journey.name);
-      this.totalTests += attributes.tests;
-      this.totalFailures += attributes.failures;
-      this.totalSkipped += attributes.skipped;
-    });
+  override async onEnd() {
+    const root: XMLEntry = {
+      name: 'testsuites',
+      attributes: {
+        name: '',
+        tests: this.totalTests,
+        failures: this.totalFailures,
+        skipped: this.totalSkipped,
+        errors: 0,
+        time: parseInt(String(now())) / 1000,
+      },
+      children: [...this.#journeyMap.values()],
+    };
 
-    this.runner.on('end', () => {
-      const root: XMLEntry = {
-        name: 'testsuites',
-        attributes: {
-          name: '',
-          tests: this.totalTests,
-          failures: this.totalFailures,
-          skipped: this.totalSkipped,
-          errors: 0,
-          time: parseInt(String(now())) / 1000,
-        },
-        children: [...journeyMap.values()],
-      };
-      const output = serializeEntries(root).join('\n');
-      /**
-       * write the xml output to a file if specified via env flag
-       */
-      const fileName = process.env['SYNTHETICS_JUNIT_FILE'];
-      if (fileName) {
-        mkdirSync(dirname(fileName), { recursive: true });
-        writeFileSync(fileName, output);
-      } else {
-        this.write(output);
-      }
-    });
+    const output = serializeEntries(root).join('\n');
+    /**
+     * write the xml output to a file if specified via env flag
+     */
+    const fileName = process.env['SYNTHETICS_JUNIT_FILE'];
+    if (fileName) {
+      await mkdir(dirname(fileName), { recursive: true });
+      await writeFile(fileName, output);
+    } else {
+      this.write(output);
+    }
   }
 }
 

package/templates/journeys/example.journey.ts

@@ -0,0 +1,18 @@
+import { journey, step, monitor, expect } from '@elastic/synthetics';
+
+journey('My Example Journey', ({ page, params }) => {
+  // Only relevant for the push command to create
+  // monitors in Kibana
+  monitor.use({
+    id: 'example-monitor',
+    schedule: 10,
+  });
+  step('launch application', async () => {
+    await page.goto(params.url);
+  });
+
+  step('assert title', async () => {
+    const header = await page.$('h1');
+    expect(await header.textContent()).toBe('todos');
+  });
+});

package/templates/synthetics.config.ts

@@ -0,0 +1,19 @@
+import type { SyntheticsConfig } from '@elastic/synthetics';
+
+export default env => {
+  const config: SyntheticsConfig = {
+    params: {
+      url: 'https://elastic.github.io/synthetics-demo/',
+    },
+    playwrightOptions: {
+      ignoreHTTPSErrors: false,
+    },
+  };
+  if (env !== 'development') {
+    /**
+     * Override configuration specific to environment
+     * Ex: config.params.url = ""
+     */
+  }
+  return config;
+};