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

package/src/push/index.ts

@@ -0,0 +1,63 @@
+/**
+ * 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 {
+  createMonitors,
+  ok,
+  formatAPIError,
+  formatFailedMonitors,
+  formatStaleMonitors,
+  formatNotFoundError,
+} from './request';
+import { Monitor } from '../dsl/monitor';
+import { PushOptions } from '../common_types';
+import { buildMonitorSchema } from './monitor';
+import { progress, error, done, write } from '../helpers';
+
+export async function push(monitors: Monitor[], options: PushOptions) {
+  progress(`preparing all monitors`);
+  const schemas = await buildMonitorSchema(monitors);
+  try {
+    progress(`creating all monitors`);
+    const { body, statusCode } = await createMonitors(schemas, options);
+    if (statusCode === 404) {
+      throw formatNotFoundError(await body.text());
+    }
+    if (!ok(statusCode)) {
+      const { error, message } = await body.json();
+      throw formatAPIError(statusCode, error, message);
+    }
+    const { staleMonitors, failedMonitors } = await body.json();
+    if (failedMonitors.length > 0) {
+      throw formatFailedMonitors(failedMonitors);
+    }
+    if (staleMonitors.length > 0) {
+      write(formatStaleMonitors());
+    }
+    done('Pushed');
+  } catch (e) {
+    error(e);
+  }
+}

package/src/push/monitor.ts

@@ -0,0 +1,77 @@
+/**
+ * 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 { mkdir } from 'fs/promises';
+import { join } from 'path';
+import { Bundler } from './bundler';
+import { CACHE_PATH } from '../helpers';
+import {
+  Monitor,
+  MonitorConfig,
+  SyntheticsLocationsType,
+} from '../dsl/monitor';
+
+export type MonitorSchema = Omit<MonitorConfig, 'locations'> & {
+  content: string;
+  locations: string[];
+  filter: Monitor['filter'];
+};
+
+// Internal representation of Locations that would be used when
+// talking to the Kibana API
+const LocationsMap: Record<SyntheticsLocationsType, string> = {
+  'US East': 'us-east4-a',
+  'EU West': 'europe-west2-a',
+};
+function translateLocation(locations: MonitorConfig['locations']) {
+  return locations.map(loc => LocationsMap[loc]).filter(Boolean);
+}
+
+export async function buildMonitorSchema(monitors: Monitor[]) {
+  if (monitors.length == 0) {
+    throw new Error('No Monitors found');
+  }
+  /**
+   * Set up the bundle artifacts path which can be used to
+   * create the bundles required for uploading journeys
+   */
+  const bundlePath = join(CACHE_PATH, 'bundles');
+  await mkdir(bundlePath, { recursive: true });
+  const bundler = new Bundler();
+  const schemas: MonitorSchema[] = [];
+
+  for (const monitor of monitors) {
+    const { source, config, filter } = monitor;
+    const outPath = join(bundlePath, config.name + '.zip');
+    const content = await bundler.build(source.file, outPath);
+    schemas.push({
+      ...config,
+      content,
+      locations: translateLocation(config.locations),
+      filter: filter,
+    });
+  }
+  return schemas;
+}

package/src/push/plugin.ts

@@ -0,0 +1,113 @@
+/**
+ * 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 path from 'path';
+import fs from 'fs/promises';
+import * as esbuild from 'esbuild';
+
+export function commonOptions(): esbuild.BuildOptions {
+  return {
+    bundle: true,
+    external: ['node_modules', '@elastic/synthetics'],
+    minify: false,
+    platform: 'node',
+    format: 'esm',
+    write: false,
+    outExtension: {
+      '.js': '.js',
+    },
+  };
+}
+
+export type PluginData = {
+  path: string;
+  contents: string;
+};
+export type PluginCallback = (data: PluginData) => void;
+
+export function MultiAssetPlugin(callback: PluginCallback): esbuild.Plugin {
+  const isBare = (str: string) => {
+    if (str.startsWith('/') || str.startsWith('./') || str.startsWith('../')) {
+      return true;
+    }
+    return false;
+  };
+
+  return {
+    name: 'esbuild-multiasset-plugin',
+    setup(build) {
+      build.onResolve({ filter: /.*?/ }, async args => {
+        // External and other packages need be marked external to
+        // be removed from the bundle
+        if (
+          build.initialOptions.external?.includes(args.path) ||
+          !isBare(args.path)
+        ) {
+          return {
+            external: true,
+          };
+        }
+
+        if (args.kind === 'entry-point') {
+          return {
+            path: args.path,
+            namespace: 'asset',
+          };
+        }
+
+        // If the modules are resolved locally, then
+        // use the imported path to get full path
+        const entryPath =
+          path.join(path.dirname(args.importer), args.path) +
+          path.extname(args.importer);
+        // Spin off another build to copy over the imported modules without bundling
+        const result = await esbuild.build({
+          ...commonOptions(),
+          entryPoints: {
+            [entryPath]: entryPath,
+          },
+          bundle: false,
+          external: [],
+        });
+
+        callback({
+          path: entryPath,
+          contents: result.outputFiles[0].text,
+        });
+
+        return {
+          errors: result.errors,
+          external: true,
+        };
+      });
+
+      build.onLoad({ filter: /.*?/, namespace: 'asset' }, async args => {
+        const contents = await fs.readFile(args.path, 'utf-8');
+        callback({ path: args.path, contents });
+        return { contents };
+      });
+    },
+  };
+}

package/src/push/request.ts

@@ -0,0 +1,123 @@
+/**
+ * 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 { bold, gray, yellow } from 'kleur/colors';
+import { request } from 'undici';
+import { PushOptions } from '../common_types';
+import { indent, symbols } from '../helpers';
+import { MonitorSchema } from './monitor';
+
+/* eslint-disable @typescript-eslint/no-var-requires */
+const { version } = require('../../package.json');
+
+export type APISchema = {
+  project: string;
+  keep_stale: boolean;
+  monitors: MonitorSchema[];
+};
+
+function encodeAuth(auth: string) {
+  if (auth.includes(':')) {
+    return Buffer.from(auth).toString('base64');
+  }
+  return auth;
+}
+
+function getAPIUrl(options: PushOptions) {
+  return (
+    options.url + `/s/${options.space}/api/synthetics/service/project/monitors`
+  );
+}
+
+export function ok(statusCode: number) {
+  return statusCode >= 200 && statusCode <= 299;
+}
+
+export async function createMonitors(
+  monitors: MonitorSchema[],
+  options: PushOptions
+) {
+  const schema: APISchema = {
+    project: options.project,
+    keep_stale: !options.delete,
+    monitors,
+  };
+
+  return await request(getAPIUrl(options), {
+    method: 'PUT',
+    body: JSON.stringify(schema),
+    headers: {
+      authorization: `Basic ${encodeAuth(options.auth)}`,
+      'content-type': 'application/json',
+      'user-agent': `Elastic/Synthetics ${version}`,
+      'kbn-xsrf': 'true',
+    },
+  });
+}
+
+export type APIMonitorError = {
+  id?: string;
+  reason: string;
+  details: string;
+};
+
+export function formatNotFoundError(message: string) {
+  return bold(
+    `${symbols['failed']} Please check your kibana url and try again - 404:${message}`
+  );
+}
+
+export function formatAPIError(
+  statuCode: number,
+  error: string,
+  message: string
+) {
+  let outer = bold(`${symbols['failed']} Error\n`);
+  let inner = bold(
+    `${symbols['failed']} monitor creation failed - ${statuCode}:${error}\n`
+  );
+  inner += indent(message, '    ');
+  outer += indent(inner);
+  return outer;
+}
+
+export function formatFailedMonitors(errors: APIMonitorError[]) {
+  let outer = bold(`${symbols['failed']} Error\n`);
+  for (const error of errors) {
+    const monitorId = error.id ? `: monitor(${error.id})` : '';
+    let inner = bold(`> ${error.reason}${monitorId}\n`);
+    inner += indent(error.details, '    ');
+    outer += indent(inner) + '\n';
+    outer += '\n';
+  }
+  return outer;
+}
+
+export function formatStaleMonitors() {
+  let outer = bold(yellow(`${symbols['warning']} Found stale monitors\n`));
+  const inner = gray(`Pass --delete to remove all the stale monitors.`);
+  outer += indent(inner, '   ');
+  return outer;
+}

package/src/reporters/base.ts

@@ -25,7 +25,6 @@
 
 import SonicBoom from 'sonic-boom';
 import { green, red, cyan } from 'kleur/colors';
-import Runner from '../core/runner';
 import {
   symbols,
   indent,
@@ -33,7 +32,13 @@ import {
   findPWLogsIndexes,
   rewriteErrorStack,
 } from '../helpers';
-import { ReporterOptions } from './reporter';
+import { Reporter, ReporterOptions } from '.';
+import {
+  JourneyEndResult,
+  JourneyStartResult,
+  StepEndResult,
+} from '../common_types';
+import { Journey, Step } from '../dsl';
 
 function renderError(error) {
   let output = '';
@@ -58,11 +63,16 @@ function renderDuration(durationMs) {
   return parseInt(durationMs);
 }
 
-export default class BaseReporter {
+export default class BaseReporter implements Reporter {
   stream: SonicBoom;
   fd: number;
+  metrics = {
+    succeeded: 0,
+    failed: 0,
+    skipped: 0,
+  };
 
-  constructor(public runner: Runner, options: ReporterOptions = {}) {
+  constructor(options: ReporterOptions = {}) {
     this.fd = options.fd || process.stdout.fd;
     /**
      * minLength is set to 1 byte to make sure we flush the
@@ -70,66 +80,57 @@ export default class BaseReporter {
      * before destroying the pipe with underlying file descriptor
      */
     this.stream = new SonicBoom({ fd: this.fd, sync: true, minLength: 1 });
-
-    // flushSync is used here to make sure all the data from the underlying
-    // SonicBoom stream buffer is completely written to the fd before closing
-    // the process
-    this.runner.on('end', () => this.stream.flushSync());
-
-    this._registerListeners();
   }
 
-  _registerListeners() {
-    const result = {
-      succeeded: 0,
-      failed: 0,
-      skipped: 0,
-    };
-
-    this.runner.on('journey:start', ({ journey }) => {
-      this.write(`\nJourney: ${journey.name}`);
-    });
-
-    this.runner.on('step:end', ({ step, start, end, error, status }) => {
-      const message = `${symbols[status]}  Step: '${
-        step.name
-      }' ${status} (${renderDuration((end - start) * 1000)} ms)`;
-      this.write(indent(message));
-      error && this.write(renderError(error));
-      result[status]++;
-    });
-
-    this.runner.on('journey:end', ({ error }) => {
-      const { failed, succeeded, skipped } = result;
-      const total = failed + succeeded + skipped;
+  onJourneyStart(journey: Journey, {}: JourneyStartResult) {
+    this.write(`\nJourney: ${journey.name}`);
+  }
 
-      /**
-       * Render the error on the terminal only when no steps could
-       * be executed which means the error happened in one of the hooks
-       */
-      if (total === 0 && error) {
-        this.write(renderError(error));
-      }
-    });
+  onStepEnd(journey: Journey, step: Step, result: StepEndResult) {
+    const { status, end, start, error } = result;
+    const message = `${symbols[status]}  Step: '${
+      step.name
+    }' ${status} (${renderDuration((end - start) * 1000)} ms)`;
+    this.write(indent(message));
+    error && this.write(renderError(error));
+    this.metrics[status]++;
+  }
 
-    this.runner.on('end', () => {
-      const { failed, succeeded, skipped } = result;
-      const total = failed + succeeded + skipped;
+  /* eslint-disable @typescript-eslint/no-unused-vars */
+  onJourneyEnd(journey: Journey, { error }: JourneyEndResult) {
+    const { failed, succeeded, skipped } = this.metrics;
+    const total = failed + succeeded + skipped;
+    /**
+     * Render the error on the terminal only when no steps could
+     * be executed which means the error happened in one of the hooks
+     */
+    if (total === 0 && error) {
+      this.write(renderError(error));
+    }
+  }
 
-      let message = '\n';
-      if (total === 0) {
-        message = 'No tests found!';
-        message += ` (${renderDuration(now())} ms) \n`;
-        this.write(message);
-        return;
-      }
+  onEnd() {
+    const { failed, succeeded, skipped } = this.metrics;
+    const total = failed + succeeded + skipped;
 
-      message += succeeded > 0 ? green(` ${succeeded} passed`) : '';
-      message += failed > 0 ? red(` ${failed} failed`) : '';
-      message += skipped > 0 ? cyan(` ${skipped} skipped`) : '';
+    let message = '\n';
+    if (total === 0) {
+      message = 'No tests found!';
       message += ` (${renderDuration(now())} ms) \n`;
       this.write(message);
-    });
+      return;
+    }
+
+    message += succeeded > 0 ? green(` ${succeeded} passed`) : '';
+    message += failed > 0 ? red(` ${failed} failed`) : '';
+    message += skipped > 0 ? cyan(` ${skipped} skipped`) : '';
+    message += ` (${renderDuration(now())} ms) \n`;
+    this.write(message);
+
+    // flushSync is used here to make sure all the data from the underlying
+    // SonicBoom stream buffer is completely written to the fd before closing
+    // the process
+    this.stream.flushSync();
   }
 
   write(message) {

package/src/reporters/index.ts

@@ -26,11 +26,34 @@
 import BaseReporter from './base';
 import JSONReporter from './json';
 import JUnitReporter from './junit';
-import Reporter, { ReporterOptions } from './reporter';
+import { Journey, Step } from '../dsl';
+import {
+  StartEvent,
+  JourneyEndResult,
+  JourneyStartResult,
+  StepEndResult,
+} from '../common_types';
 
-export { Reporter, ReporterOptions };
-export const reporters = {
+export type ReporterOptions = { fd?: number; colors?: boolean };
+export type BuiltInReporterName = 'default' | 'json' | 'junit';
+export type ReporterInstance = new (opts: ReporterOptions) => Reporter;
+export const reporters: {
+  [key in BuiltInReporterName]: ReporterInstance;
+} = {
   default: BaseReporter,
   json: JSONReporter,
   junit: JUnitReporter,
 };
+
+export interface Reporter {
+  onStart?(params: StartEvent): void;
+  onJourneyRegister?(journey: Journey): void;
+  onJourneyStart?(journey: Journey, result: JourneyStartResult): void;
+  onStepStart?(journey: Journey, step: Step): void;
+  onStepEnd?(journey: Journey, step: Step, result: StepEndResult): void;
+  onJourneyEnd?(
+    journey: Journey,
+    result: JourneyEndResult
+  ): void | Promise<void>;
+  onEnd?(): void | Promise<void>;
+}