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

package/src/plugins/plugin-manager.ts

@@ -23,7 +23,7 @@
  *
  */
 
-import { PluginOutput } from '../common_types';
+import { PluginOutput, Driver } from '../common_types';
 import {
   BrowserConsole,
   NetworkManager,
@@ -31,7 +31,6 @@ import {
   Tracing,
   TraceOptions,
 } from './';
-import { Driver } from '../core/gatherer';
 import { Step } from '../dsl';
 
 type PluginType = 'network' | 'trace' | 'performance' | 'browserconsole';
@@ -39,59 +38,78 @@ type Plugin = NetworkManager | Tracing | PerformanceManager | BrowserConsole;
 type PluginOptions = TraceOptions;
 
 export class PluginManager {
-  protected plugins = new Map<string, Plugin>();
-
+  protected plugins = new Map<PluginType, Plugin>();
+  public PLUGIN_TYPES: Array<PluginType> = [
+    'network',
+    'trace',
+    'performance',
+    'browserconsole',
+  ];
   constructor(private driver: Driver) {}
 
-  async start(type: PluginType, options?: PluginOptions) {
+  register(type: PluginType, options: PluginOptions) {
     let instance: Plugin;
     switch (type) {
       case 'network':
-        instance = new NetworkManager();
-        await instance.start(this.driver.client);
+        instance = new NetworkManager(this.driver);
         break;
       case 'trace':
-        instance = new Tracing(options);
-        await instance.start(this.driver.client);
+        instance = new Tracing(this.driver, options);
         break;
       case 'performance':
-        instance = new PerformanceManager(this.driver.client);
-        instance.start();
+        instance = new PerformanceManager(this.driver);
         break;
       case 'browserconsole':
-        instance = new BrowserConsole(this.driver.page);
-        instance.start();
+        instance = new BrowserConsole(this.driver);
         break;
     }
+    instance && this.plugins.set(type, instance);
+    return instance;
+  }
+
+  registerAll(options: PluginOptions) {
+    for (const type of this.PLUGIN_TYPES) {
+      this.register(type, options);
+    }
+  }
+
+  unregisterAll() {
+    for (const type of this.PLUGIN_TYPES) {
+      this.plugins.delete(type);
+    }
+  }
+
+  async stop(type: PluginType) {
+    const instance = this.plugins.get(type);
+    if (instance) {
+      return await instance.stop();
+    }
+    return {};
+  }
 
-    this.plugins.set(instance.constructor.name, instance);
+  async start(type: PluginType) {
+    const instance = this.plugins.get(type);
+    instance && (await instance.start());
     return instance;
   }
 
-  get<T extends Plugin>(Type: new (...args: any[]) => T): T {
-    return this.plugins.get(Type.name) as T;
+  get(type: PluginType) {
+    return this.plugins.get(type);
   }
 
   onStep(step: Step) {
-    this.get(BrowserConsole) && (this.get(BrowserConsole)._currentStep = step);
-    this.get(NetworkManager) && (this.get(NetworkManager)._currentStep = step);
+    (this.get('browserconsole') as BrowserConsole)._currentStep = step;
+    (this.get('network') as NetworkManager)._currentStep = step;
   }
 
-  async output(): Promise<PluginOutput> {
+  async output() {
     const data: PluginOutput = {};
-    try {
-      for (const [, plugin] of this.plugins) {
-        if (plugin instanceof NetworkManager) {
-          data.networkinfo = plugin.stop();
-        } else if (plugin instanceof Tracing) {
-          const result = await plugin.stop(this.driver.client);
-          Object.assign(data, { ...result });
-        } else if (plugin instanceof BrowserConsole) {
-          data.browserconsole = plugin.stop();
-        }
+    for (const [, plugin] of this.plugins) {
+      if (plugin instanceof NetworkManager) {
+        data.networkinfo = await plugin.stop();
+      } else if (plugin instanceof BrowserConsole) {
+        data.browserconsole = plugin.stop();
       }
-    } catch (e) {
-      console.error('Error capturing data', e.message);
     }
     return data;
   }

package/src/plugins/tracing.ts

@@ -23,8 +23,7 @@
  *
  */
 
-import { CDPSession } from 'playwright-chromium';
-import { PluginOutput } from '../common_types';
+import { Driver, PluginOutput } from '../common_types';
 import { Filmstrips } from '../sdk/trace-metrics';
 import { TraceEvent, TraceProcessor } from '../sdk/trace-processor';
 
@@ -38,9 +37,9 @@ export type TraceOptions = {
  * https://chromedevtools.github.io/devtools-protocol/tot/Tracing/
  */
 export class Tracing {
-  constructor(public options: TraceOptions) {}
+  constructor(private driver: Driver, private options: TraceOptions) {}
 
-  async start(client: CDPSession) {
+  async start() {
     const includedCategories = [
       // exclude all default categories
       '-*',
@@ -63,21 +62,21 @@ export class Tracing {
         'disabled-by-default-devtools.timeline'
       );
     }
-    await client.send('Tracing.start', {
+    await this.driver.client.send('Tracing.start', {
       /**
        * Using `ReportEvents` makes gathering trace events
        * much faster as opposed to using `ReturnAsStream` mode
        */
       transferMode: 'ReportEvents',
-      traceConfig: {
-        includedCategories,
-      },
+      categories: includedCategories.join(','),
+      options: 'sampling-frequency=10000', // 1000 is default
     });
   }
 
-  async stop(client: CDPSession) {
+  async stop() {
     const events = [];
     const collectListener = payload => events.push(...payload.value);
+    const { client } = this.driver;
     client.on('Tracing.dataCollected', collectListener);
 
     const [traceEvents] = await Promise.all([

package/src/push/bundler.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 path from 'path';
+import { unlink, readFile } from 'fs/promises';
+import { createWriteStream } from 'fs';
+import * as esbuild from 'esbuild';
+import archiver from 'archiver';
+import { commonOptions, MultiAssetPlugin, PluginData } from './plugin';
+
+function relativeToCwd(entry: string) {
+  return path.relative(process.cwd(), entry);
+}
+
+export class Bundler {
+  moduleMap = new Map<string, string>();
+  constructor() {}
+
+  async prepare(absPath: string) {
+    const addToMap = (data: PluginData) => {
+      this.moduleMap.set(data.path, data.contents);
+    };
+
+    const options: esbuild.BuildOptions = {
+      ...commonOptions(),
+      ...{
+        entryPoints: {
+          [absPath]: absPath,
+        },
+        plugins: [MultiAssetPlugin(addToMap)],
+      },
+    };
+    const result = await esbuild.build(options);
+    if (result.errors.length > 0) {
+      throw result.errors;
+    }
+    this.moduleMap.set(absPath, result.outputFiles[0].text);
+  }
+
+  async zip(outputPath: string) {
+    return new Promise((fulfill, reject) => {
+      const output = createWriteStream(outputPath);
+      const archive = archiver('zip', {
+        zlib: { level: 9 },
+      });
+      archive.on('error', err => reject(err));
+      output.on('close', fulfill);
+      archive.pipe(output);
+      for (const [path, content] of this.moduleMap.entries()) {
+        const relativePath = relativeToCwd(path);
+        archive.append(content, { name: relativePath });
+      }
+      archive.finalize();
+    });
+  }
+
+  async build(entry: string, output: string) {
+    await this.prepare(entry);
+    await this.zip(output);
+    const data = await this.encode(output);
+    await this.cleanup(output);
+    return data;
+  }
+
+  async encode(outputPath: string) {
+    return await readFile(outputPath, 'base64');
+  }
+
+  async cleanup(outputPath: string) {
+    this.moduleMap = new Map<string, string>();
+    await unlink(outputPath);
+  }
+}

package/src/push/index.ts

@@ -0,0 +1,59 @@
+/**
+ * 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,
+  formatNotFoundError,
+} from './request';
+import { Monitor } from '../dsl/monitor';
+import { PushOptions } from '../common_types';
+import { buildMonitorSchema } from './monitor';
+import { progress, error, done } 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 { failedMonitors } = await body.json();
+    if (failedMonitors.length > 0) {
+      throw formatFailedMonitors(failedMonitors);
+    }
+    done('Pushed');
+  } catch (e) {
+    error(e);
+  }
+}

package/src/push/monitor.ts

@@ -0,0 +1,68 @@
+/**
+ * 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 { LocationsMap } from '../dsl/locations';
+import { Monitor, MonitorConfig } from '../dsl/monitor';
+
+export type MonitorSchema = Omit<MonitorConfig, 'locations'> & {
+  content: string;
+  locations: string[];
+  filter: Monitor['filter'];
+};
+
+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,114 @@
+/**
+ * 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',
+    logLevel: 'silent',
+    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,111 @@
+/**
+ * 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 } 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 getAPIUrl(options: PushOptions) {
+  // remove trialing / as well
+  return (
+    options.url.replace(/\/+$/, '') +
+    `/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: false,
+    monitors,
+  };
+
+  return await request(getAPIUrl(options), {
+    method: 'PUT',
+    body: JSON.stringify(schema),
+    headers: {
+      authorization: `ApiKey ${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;
+}