@elastic/synthetics 1.0.0-beta.35 → 1.0.0-beta.36

package/src/push/index.ts

@@ -40,7 +40,7 @@ import {
   apiProgress,
   write,
   error,
-  aborted,
+  warn,
   indent,
   safeNDJSONParse,
   done,
@@ -79,7 +79,7 @@ export async function push(monitors: Monitor[], options: PushOptions) {
       initial: false,
     });
     if (!deleteAll) {
-      throw aborted('Push command Aborted');
+      throw warn('Push command Aborted');
     }
   }
   progress(`deleting all stale monitors`);
@@ -207,7 +207,7 @@ async function overrideSettings(oldValue: string, newValue: string) {
   const cwd = process.cwd();
   const configPath = await findSyntheticsConfig(cwd, cwd);
   if (!configPath) {
-    throw aborted(`Unable to find synthetics config file: ${configPath}`);
+    throw warn(`Unable to find synthetics config file: ${configPath}`);
   }
   const config = await readFile(configPath, 'utf-8');
   const updatedConfig = config.replace(
@@ -239,7 +239,7 @@ export async function catchIncorrectSettings(
       initial: false,
     }));
     if (!override) {
-      throw aborted('Push command Aborted');
+      throw warn('Push command Aborted');
     }
   }
   if (override) {

package/src/push/monitor.ts

@@ -23,19 +23,27 @@
  *
  */
 
-import { mkdir, rm } from 'fs/promises';
+import { mkdir, rm, readFile } from 'fs/promises';
 import { join } from 'path';
+import { LineCounter, parseDocument, YAMLSeq, YAMLMap } from 'yaml';
+import { bold, red } from 'kleur/colors';
 import { Bundler } from './bundler';
 import { sendRequest } from './request';
-import { removeTrailingSlash, SYNTHETICS_PATH } from '../helpers';
+import {
+  removeTrailingSlash,
+  SYNTHETICS_PATH,
+  totalist,
+  indent,
+  warn,
+} from '../helpers';
 import { LocationsMap } from '../locations/public-locations';
 import { Monitor, MonitorConfig } from '../dsl/monitor';
 import { PushOptions } from '../common_types';
 
 export type MonitorSchema = Omit<MonitorConfig, 'locations'> & {
-  content: string;
   locations: string[];
-  filter: Monitor['filter'];
+  content?: string;
+  filter?: Monitor['filter'];
 };
 
 export type APISchema = {
@@ -60,21 +68,134 @@ export async function buildMonitorSchema(monitors: Monitor[]) {
   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({
+    const { source, config, filter, type } = monitor;
+    const schema = {
       ...config,
-      content,
       locations: translateLocation(config.locations),
-      filter: filter,
-    });
+    };
+    if (type === 'browser') {
+      const outPath = join(bundlePath, config.name + '.zip');
+      const content = await bundler.build(source.file, outPath);
+      Object.assign(schema, { content, filter });
+    }
+    schemas.push(schema);
   }
 
   await rm(bundlePath, { recursive: true });
   return schemas;
 }
 
+export async function createLightweightMonitors(
+  workDir: string,
+  options: PushOptions
+) {
+  const lwFiles = new Set<string>();
+  await totalist(workDir, (rel, abs) => {
+    if (/.(yml|yaml)$/.test(rel)) {
+      lwFiles.add(abs);
+    }
+  });
+  // Warn users about schedule that are less than 60 seconds
+  if (lwFiles.size > 0) {
+    warn(
+      'lightweight monitors schedule < 1 minute resolution are not supported, will get reset to their nearest minute interval.'
+    );
+  }
+
+  const monitors: Monitor[] = [];
+  for (const file of lwFiles.values()) {
+    const content = await readFile(file, 'utf-8');
+    const lineCounter = new LineCounter();
+    const parsedDoc = parseDocument(content, {
+      lineCounter,
+      keepSourceTokens: true,
+    });
+    // Skip other yml files that are not relevant
+    const monitorSeq = parsedDoc.get('heartbeat.monitors') as YAMLSeq<YAMLMap>;
+    if (!monitorSeq) {
+      continue;
+    }
+
+    for (const monNode of monitorSeq.items) {
+      // Skip browser monitors and disabled monitors from pushing
+      if (
+        monNode.get('type') === 'browser' ||
+        monNode.get('enabled') === false
+      ) {
+        continue;
+      }
+      const config = monNode.toJSON();
+      const { line, col } = lineCounter.linePos(monNode.srcToken.offset);
+      try {
+        const mon = buildMonitorFromYaml(config, options);
+        mon.setSource({ file, line, column: col });
+        monitors.push(mon);
+      } catch (e) {
+        let outer = bold(`Aborted: ${e}\n`);
+        outer += indent(
+          `* ${config.id || config.name} - ${file}:${line}:${col}\n`
+        );
+        throw red(outer);
+      }
+    }
+  }
+  return monitors;
+}
+
+const REQUIRED_MONITOR_FIELDS = ['id', 'name'];
+export function buildMonitorFromYaml(
+  config: MonitorConfig,
+  options: PushOptions
+) {
+  // Validate required fields
+  for (const field of REQUIRED_MONITOR_FIELDS) {
+    if (!config[field]) {
+      throw `Monitor ${field} is required`;
+    }
+  }
+  const schedule = config.schedule && parseSchedule(String(config.schedule));
+  const privateLocations =
+    config['private_locations'] || options.privateLocations;
+  delete config['private_locations'];
+
+  return new Monitor({
+    locations: options.locations,
+    ...config,
+    privateLocations,
+    schedule: schedule || options.schedule,
+  });
+}
+
+export function parseSchedule(schedule: string) {
+  const EVERY_SYNTAX = '@every';
+  if (!(schedule + '').startsWith(EVERY_SYNTAX)) {
+    throw `Monitor schedule format(${schedule}) not supported: use '@every' syntax instead`;
+  }
+
+  const duration = schedule.substring(EVERY_SYNTAX.length + 1);
+  // split between non-digit (\D) and a digit (\d)
+  const durations = duration.split(/(?<=\D)(?=\d)/g);
+  let minutes = 0;
+  for (const dur of durations) {
+    // split between a digit and non-digit
+    const [value, format] = dur.split(/(?<=\d)(?=\D)/g);
+    // Calculate based on the duration symbol
+    const scheduleValue = parseInt(value, 10);
+    switch (format) {
+      case 's':
+        minutes += Math.ceil(scheduleValue / 60);
+        break;
+      case 'm':
+        minutes += scheduleValue;
+        break;
+      case 'h':
+        minutes += scheduleValue * 60;
+        break;
+    }
+  }
+  return minutes;
+}
+
 export async function createMonitors(
   monitors: MonitorSchema[],
   options: PushOptions,

package/src/push/plugin.ts

@@ -27,8 +27,12 @@ import { isAbsolute, dirname, extname, join } from 'path';
 import fs from 'fs/promises';
 import * as esbuild from 'esbuild';
 
-const SOURCE_DIR = join(__dirname, '..', '..');
-const SOURCE_NODE_MODULES = join(SOURCE_DIR, 'node_modules');
+// ROOT directory of the Package - /
+const ROOT_DIR = join(__dirname, '..', '..');
+// Source of the package - /src, /dist, etc.
+const SOURCE_DIR = join(__dirname, '..');
+// Node modules directory of the package - /node_modules
+const SOURCE_NODE_MODULES = join(ROOT_DIR, 'node_modules');
 
 export function commonOptions(): esbuild.BuildOptions {
   return {