@elastic/synthetics 1.0.0-beta.8 → 1.0.0

package/src/core/transform.ts

@@ -0,0 +1,160 @@
+/**
+ * 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 { addHook } from 'pirates';
+import {
+  transformSync,
+  Loader,
+  CommonOptions,
+  TransformOptions,
+} from 'esbuild';
+import path from 'path';
+import sourceMapSupport from 'source-map-support';
+
+// Cache that holds the sourcemap content for each file
+const sourceMaps: Map<string, string> = new Map();
+
+// Register the source-map-support library to resolve the sourcemaps
+// for the files that are transpiled by esbuild
+/**
+ * Register the source-map-support library to resolve the sourcemaps
+ * for the files that are transpiled by esbuild and cache the sourcemaps
+ * for each file.
+ *
+ * Caching the sourcemap file is important, as it is used by the Synthetics agent
+ * to resolve the stack traces of journey, monitor and step functions.
+ */
+sourceMapSupport.install({
+  environment: 'node',
+  handleUncaughtExceptions: false,
+  retrieveSourceMap(source) {
+    if (!sourceMaps.has(source)) return null;
+    return {
+      map: JSON.parse(sourceMaps.get(source)),
+      url: source,
+    };
+  },
+});
+
+/**
+ * Default list of files and corresponding loaders we support
+ * while pushing project based monitors
+ */
+const LOADERS: Record<string, Loader> = {
+  '.ts': 'ts',
+  '.js': 'js',
+  '.mjs': 'js',
+  '.cjs': 'js',
+};
+
+const getLoader = (filename: string) => {
+  const ext = path.extname(filename);
+  return LOADERS[ext] || 'default';
+};
+
+export function commonOptions(): CommonOptions {
+  /**
+   * We are not minifying the code as we want it to be in sync with previous
+   * transformation phase and introduce it later.
+   */
+  return {
+    minify: false,
+    minifyIdentifiers: false,
+    minifySyntax: false,
+    minifyWhitespace: false,
+    sourcemap: 'both',
+    sourcesContent: false,
+    platform: 'node',
+    logLevel: 'silent',
+    format: 'cjs',
+    target: `node${process.version.slice(1)}`,
+  };
+}
+
+/**
+ * Transform the given code using esbuild and save the corresponding
+ * map file in memory to be retrived later.
+ */
+export function transform(
+  code: string,
+  filename: string,
+  options: TransformOptions = {}
+) {
+  const result = transformSync(code, {
+    ...commonOptions(),
+    sourcefile: filename,
+    loader: getLoader(filename),
+    /**
+     * Add this only for the transformation phase, using it on
+     * bundling phase would disable tree shaking and uncessary bloat
+     *
+     * Ensures backwards compatability with tsc's implicit strict behaviour
+     */
+    tsconfigRaw: {
+      compilerOptions: {
+        alwaysStrict: true,
+      },
+    },
+    ...options,
+  });
+
+  const warnings = result.warnings;
+  if (warnings && warnings.length > 0) {
+    for (const warning of warnings) {
+      console.log(warning.location);
+      console.log(warning.text);
+    }
+  }
+
+  /**
+   * Cache the sourcemap contents in memory, so we can look it up
+   * later when we try to resolve the sourcemap for a given file.
+   *
+   * Every time the synthetics agent is started, we register the source-map-support
+   * library to resolve the sourcemaps for the files that are transpiled by esbuild.
+   */
+  if (result.map) {
+    sourceMaps.set(filename, result.map);
+  }
+  return result;
+}
+
+/**
+ * Install the pirates hook to transform the code on the fly
+ * for all of the imported files.
+ */
+export function installTransform() {
+  const revertPirates = addHook(
+    (source: string, filename: string) => {
+      const { code } = transform(source, filename);
+      return code;
+    },
+    { exts: ['.ts', '.js', '.mjs', '.cjs'] }
+  );
+
+  return () => {
+    revertPirates();
+  };
+}

package/src/dsl/journey.ts

@@ -23,10 +23,17 @@
  *
  */
 
-import { Browser, Page, BrowserContext, CDPSession } from 'playwright-chromium';
-import micromatch, { isMatch } from 'micromatch';
+import {
+  Browser,
+  Page,
+  BrowserContext,
+  CDPSession,
+  APIRequestContext,
+} from 'playwright-chromium';
 import { Step } from './step';
-import { VoidCallback, HooksCallback, Params } from '../common_types';
+import { VoidCallback, HooksCallback, Params, Location } from '../common_types';
+import { Monitor, MonitorConfig } from './monitor';
+import { isMatch } from '../helpers';
 
 export type JourneyOptions = {
   name: string;
@@ -42,6 +49,7 @@ export type JourneyCallback = (options: {
   browser: Browser;
   client: CDPSession;
   params: Params;
+  request: APIRequestContext;
 }) => void;
 
 export class Journey {
@@ -49,18 +57,26 @@ export class Journey {
   id?: string;
   tags?: string[];
   callback: JourneyCallback;
+  location?: Location;
   steps: Step[] = [];
   hooks: Hooks = { before: [], after: [] };
+  monitor: Monitor;
 
-  constructor(options: JourneyOptions, callback: JourneyCallback) {
+  constructor(
+    options: JourneyOptions,
+    callback: JourneyCallback,
+    location?: Location
+  ) {
     this.name = options.name;
-    this.id = options.id;
+    this.id = options.id || options.name;
     this.tags = options.tags;
     this.callback = callback;
+    this.location = location;
+    this.updateMonitor({});
   }
 
-  addStep(name: string, callback: VoidCallback) {
-    const step = new Step(name, this.steps.length + 1, callback);
+  addStep(name: string, callback: VoidCallback, location?: Location) {
+    const step = new Step(name, this.steps.length + 1, callback, location);
     this.steps.push(step);
     return step;
   }
@@ -68,23 +84,27 @@ export class Journey {
   addHook(type: HookType, callback: HooksCallback) {
     this.hooks[type].push(callback);
   }
+
+  updateMonitor(config: MonitorConfig) {
+    /**
+     * Use defaults values from journey for monitor object (id, name and tags)
+     */
+    this.monitor = new Monitor({
+      name: this.name,
+      id: this.id,
+      type: 'browser',
+      tags: this.tags ?? [],
+      ...config,
+    });
+    this.monitor.setSource(this.location);
+    this.monitor.setContent(this.callback.toString());
+    this.monitor.setFilter({ match: this.name });
+  }
+
   /**
    * Matches journeys based on the provided args. Proitize tags over match
-   * - tags pattern that matches only tags
-   * - match pattern that matches both name and tags
    */
   isMatch(matchPattern: string, tagsPattern: Array<string>) {
-    if (tagsPattern) {
-      return this.tagsMatch(tagsPattern);
-    }
-    if (matchPattern) {
-      return isMatch(this.name, matchPattern) || this.tagsMatch(matchPattern);
-    }
-    return true;
-  }
-
-  tagsMatch(pattern) {
-    const matchess = micromatch(this.tags || ['*'], pattern);
-    return matchess.length > 0;
+    return isMatch(this.tags, this.name, tagsPattern, matchPattern);
   }
 }

package/src/dsl/monitor.ts

@@ -0,0 +1,152 @@
+/**
+ * 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 { createHash } from 'crypto';
+import merge from 'deepmerge';
+import { bold, red } from 'kleur/colors';
+import {
+  ThrottlingOptions,
+  Location,
+  ScreenshotOptions,
+  Params,
+  PlaywrightOptions,
+} from '../common_types';
+import { indent } from '../helpers';
+import { LocationsMap } from '../locations/public-locations';
+
+export type SyntheticsLocationsType = keyof typeof LocationsMap;
+export const SyntheticsLocations = Object.keys(
+  LocationsMap
+) as SyntheticsLocationsType[];
+export const ALLOWED_SCHEDULES = [
+  1, 3, 5, 10, 15, 20, 30, 60, 120, 240,
+] as const;
+
+export type MonitorConfig = {
+  id?: string;
+  name?: string;
+  type?: string;
+  tags?: string[];
+  schedule?: typeof ALLOWED_SCHEDULES[number];
+  enabled?: boolean;
+  locations?: SyntheticsLocationsType[];
+  privateLocations?: string[];
+  /**
+   * @deprecated This option is ignored.
+   * Network throttling via chrome devtools is ignored at the moment.
+   * See https://github.com/elastic/synthetics/blob/main/docs/throttling.md for more details.
+   */
+  throttling?: boolean | ThrottlingOptions;
+  screenshot?: ScreenshotOptions;
+  params?: Params;
+  playwrightOptions?: PlaywrightOptions;
+  alert?: {
+    status: {
+      enabled: boolean;
+    };
+  };
+};
+
+type MonitorFilter = {
+  match: string;
+  tags?: string[];
+};
+
+export class Monitor {
+  content?: string;
+  source?: Location;
+  filter: MonitorFilter;
+  constructor(public config: MonitorConfig = {}) {}
+  /**
+   * Treat the creation time config with `monitor.use` as source of truth by
+   * merging the values coming from CLI and Synthetics config file
+   */
+  update(globalOpts: MonitorConfig = {}) {
+    this.config = merge(globalOpts, this.config, {
+      arrayMerge(target, source) {
+        return [...new Set(source)];
+      },
+    });
+  }
+
+  get type() {
+    return this.config.type;
+  }
+
+  setSource(source: Location) {
+    this.source = source;
+  }
+
+  /**
+   * The underlying journey code of the monitor
+   */
+  setContent(content = '') {
+    this.content = content;
+  }
+
+  /**
+   * If journey files are colocated within the same file during
+   * push command, when we invoke synthetics from HB we rely on
+   * this filter for running that specific journey alone instead of
+   * all journeys on the file
+   */
+  setFilter(filter: MonitorFilter) {
+    this.filter = filter;
+  }
+
+  /**
+   * Hash is used to identify if the monitor has changed since the last time
+   * it was pushed to Kibana. Change is based on three factors:
+   * - Monitor configuration
+   * - Code changes
+   * - File path changes
+   */
+  hash(): string {
+    const hash = createHash('sha256');
+    return hash
+      .update(JSON.stringify(this.config))
+      .update(this.content || '')
+      .update(this.source?.file || '')
+      .digest('base64');
+  }
+
+  validate() {
+    const schedule = this.config.schedule;
+    if (ALLOWED_SCHEDULES.includes(schedule)) {
+      return;
+    }
+    const { config, source } = this;
+    let outer = bold(
+      `Invalid schedule: ${schedule}, allowed values are ${ALLOWED_SCHEDULES.join(
+        ','
+      )}\n`
+    );
+    if (source) {
+      const inner = `* ${config.id} - ${source.file}:${source.line}:${source.column}\n`;
+      outer += indent(inner);
+    }
+    throw red(outer);
+  }
+}

package/src/dsl/step.ts

@@ -23,16 +23,23 @@
  *
  */
 
-import { VoidCallback } from '../common_types';
+import { Location, VoidCallback } from '../common_types';
 
 export class Step {
   name: string;
   index: number;
   callback: VoidCallback;
+  location?: Location;
 
-  constructor(name: string, index: number, callback: VoidCallback) {
+  constructor(
+    name: string,
+    index: number,
+    callback: VoidCallback,
+    location: Location
+  ) {
     this.name = name;
     this.index = index;
     this.callback = callback;
+    this.location = location;
   }
 }