@elastic/synthetics 1.0.0-beta.8 → 1.0.0

package/src/push/kibana_api.ts

@@ -0,0 +1,191 @@
+/**
+ * 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 { PushOptions } from '../common_types';
+import { safeNDJSONParse } from '../helpers';
+import { MonitorHashID, MonitorSchema } from './monitor';
+import {
+  formatFailedMonitors,
+  formatStaleMonitors,
+  handleError,
+  sendReqAndHandleError,
+  sendRequest,
+  APIMonitorError,
+} from './request';
+import { generateURL } from './utils';
+
+// Default chunk size for bulk put / delete
+export const CHUNK_SIZE = 100;
+
+export type PutResponse = {
+  createdMonitors: string[];
+  updatedMonitors: string[];
+  failedMonitors: APIMonitorError[];
+};
+
+export async function bulkPutMonitors(
+  options: PushOptions,
+  schemas: MonitorSchema[]
+) {
+  const resp = await sendReqAndHandleError<PutResponse>({
+    url: generateURL(options, 'bulk_update') + '/_bulk_update',
+    method: 'PUT',
+    auth: options.auth,
+    body: JSON.stringify({ monitors: schemas }),
+  });
+  const { failedMonitors } = resp;
+  if (failedMonitors && failedMonitors.length > 0) {
+    throw formatFailedMonitors(failedMonitors);
+  }
+  return resp;
+}
+
+export type GetResponse = {
+  total: number;
+  monitors: MonitorHashID[];
+  after_key?: string;
+};
+
+export async function bulkGetMonitors(
+  options: PushOptions
+): Promise<GetResponse> {
+  const allMonitors: MonitorHashID[] = [];
+
+  const resp = await fetchMonitors(options);
+  allMonitors.push(...resp.monitors);
+  let afterKey = resp.afterKey;
+  const total = resp.total;
+
+  while (allMonitors.length < total) {
+    const resp = await fetchMonitors(options, afterKey);
+    allMonitors.push(...resp.monitors);
+    afterKey = resp.afterKey;
+  }
+
+  return {
+    total,
+    monitors: allMonitors,
+  };
+}
+
+const fetchMonitors = async (options: PushOptions, afterKey?: string) => {
+  let url = generateURL(options, 'bulk_get');
+  if (afterKey) {
+    url += `?search_after=${afterKey}`;
+  }
+  const resp = await sendReqAndHandleError<GetResponse>({
+    url,
+    method: 'GET',
+    auth: options.auth,
+  });
+  return {
+    afterKey: resp.after_key,
+    total: resp.total,
+    monitors: resp.monitors,
+  };
+};
+
+export type DeleteResponse = {
+  deleted_monitors: string[];
+};
+
+export async function bulkDeleteMonitors(
+  options: PushOptions,
+  monitorIDs: string[]
+) {
+  return await sendReqAndHandleError<DeleteResponse>({
+    url: generateURL(options, 'bulk_delete') + '/_bulk_delete',
+    method: 'DELETE',
+    auth: options.auth,
+    body: JSON.stringify({ monitors: monitorIDs }),
+  });
+}
+
+type StatusResponse = {
+  version: {
+    number: number;
+  };
+};
+
+export async function getVersion(options: PushOptions) {
+  const data = await sendReqAndHandleError<StatusResponse>({
+    url: generateURL(options, 'status'),
+    method: 'GET',
+    auth: options.auth,
+  });
+  return data.version.number;
+}
+
+export type LegacyAPISchema = {
+  project: string;
+  keep_stale: boolean;
+  monitors: MonitorSchema[];
+};
+
+export async function createMonitorsLegacy({
+  schemas,
+  keepStale,
+  options,
+}: {
+  schemas: MonitorSchema[];
+  keepStale: boolean;
+  options: PushOptions;
+}) {
+  const schema: LegacyAPISchema = {
+    project: options.id,
+    keep_stale: keepStale,
+    monitors: schemas,
+  };
+  const url = generateURL(options, 'legacy');
+  const { body, statusCode } = await sendRequest({
+    url,
+    method: 'PUT',
+    auth: options.auth,
+    body: JSON.stringify(schema),
+  });
+
+  const resBody = await handleError(statusCode, url, body);
+  const allchunks = [];
+  for await (const data of resBody) {
+    allchunks.push(Buffer.from(data));
+  }
+  const chunks = safeNDJSONParse(Buffer.concat(allchunks).toString('utf-8'));
+  // Its kind of hacky for now where Kibana streams the response by
+  // writing the data as NDJSON events (data can be interleaved), we
+  // distinguish the final data by checking if the event was a progress vs complete event
+  for (const chunk of chunks) {
+    if (typeof chunk === 'string') {
+      // Ignore the progress from Kibana as we chunk the requests
+      continue;
+    }
+    const { failedMonitors, failedStaleMonitors } = chunk;
+    if (failedMonitors && failedMonitors.length > 0) {
+      throw formatFailedMonitors(failedMonitors);
+    }
+    if (failedStaleMonitors.length > 0) {
+      throw formatStaleMonitors(failedStaleMonitors);
+    }
+  }
+}

package/src/push/monitor.ts

@@ -0,0 +1,307 @@
+/**
+ * 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, rm, readFile } from 'fs/promises';
+import { extname, join } from 'path';
+import { LineCounter, parseDocument, YAMLSeq, YAMLMap } from 'yaml';
+import { bold, red } from 'kleur/colors';
+import { Bundler } from './bundler';
+import { SYNTHETICS_PATH, totalist, indent, warn, isMatch } from '../helpers';
+import { LocationsMap } from '../locations/public-locations';
+import { ALLOWED_SCHEDULES, Monitor, MonitorConfig } from '../dsl/monitor';
+import { PushOptions } from '../common_types';
+
+// Allowed extensions for lightweight monitor files
+const ALLOWED_LW_EXTENSIONS = ['.yml', '.yaml'];
+
+export type MonitorSchema = Omit<MonitorConfig, 'locations'> & {
+  locations: string[];
+  content?: string;
+  filter?: Monitor['filter'];
+  hash?: string;
+};
+
+// Abbreviated monitor info, as often returned by the API,
+// just the journey ID and hash
+export type MonitorHashID = {
+  journey_id?: string;
+  hash?: string;
+};
+
+function translateLocation(locations?: MonitorConfig['locations']) {
+  if (!locations) return [];
+  return locations.map(loc => LocationsMap[loc] || loc).filter(Boolean);
+}
+
+class RemoteDiffResult {
+  // The set of monitor IDs that have been added
+  newIDs = new Set<string>();
+  // Monitor IDs that are different locally than remotely
+  changedIDs = new Set<string>();
+  // Monitor IDs that are no longer present locally
+  removedIDs = new Set<string>();
+  // Monitor IDs that are identical on the remote server
+  unchangedIDs = new Set<string>();
+}
+
+export function diffMonitors(
+  local: MonitorHashID[],
+  remote: MonitorHashID[]
+): RemoteDiffResult {
+  const result = new RemoteDiffResult();
+  const localMonitorsIDToHash = new Map<string, string>();
+  for (const hashID of local) {
+    localMonitorsIDToHash.set(hashID.journey_id, hashID.hash);
+  }
+  const remoteMonitorsIDToHash = new Map<string, string>();
+  for (const hashID of remote) {
+    remoteMonitorsIDToHash.set(hashID.journey_id, hashID.hash);
+  }
+
+  // Compare local to remote
+  for (const [localID, localHash] of localMonitorsIDToHash) {
+    // Hash is reset to '' when a monitor is edited on the UI
+    if (!remoteMonitorsIDToHash.has(localID)) {
+      result.newIDs.add(localID);
+    } else {
+      const remoteHash = remoteMonitorsIDToHash.get(localID);
+      if (remoteHash != localHash) {
+        result.changedIDs.add(localID);
+      } else if (remoteHash === localHash) {
+        result.unchangedIDs.add(localID);
+      }
+    }
+    // We no longer need to process this ID, removing it here
+    // reduces the numbers considered in the next phase
+    remoteMonitorsIDToHash.delete(localID);
+  }
+
+  for (const [id] of remoteMonitorsIDToHash) {
+    result.removedIDs.add(id);
+  }
+  return result;
+}
+
+export function getLocalMonitors(monitors: Monitor[]) {
+  const data: MonitorHashID[] = [];
+  for (const monitor of monitors) {
+    data.push({
+      journey_id: monitor.config.id,
+      hash: monitor.hash(),
+    });
+  }
+  return data;
+}
+
+export async function buildMonitorSchema(monitors: Monitor[], isV2: boolean) {
+  /**
+   * Set up the bundle artifacts path which can be used to
+   * create the bundles required for uploading journeys
+   */
+  const bundlePath = join(SYNTHETICS_PATH, 'bundles');
+  await mkdir(bundlePath, { recursive: true });
+  const bundler = new Bundler();
+  const schemas: MonitorSchema[] = [];
+
+  for (const monitor of monitors) {
+    const { source, config, filter, type } = monitor;
+    const schema: MonitorSchema = {
+      ...config,
+      locations: translateLocation(config.locations),
+    };
+    if (isV2) {
+      schema.hash = monitor.hash();
+    }
+    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>();
+  // Filter monitor files based on the provided pattern
+  const pattern = options.pattern
+    ? new RegExp(options.pattern, 'i')
+    : /.(yml|yaml)$/;
+  const ignore = /(node_modules|.github)/;
+  await totalist(workDir, (rel, abs) => {
+    if (
+      !ignore.test(rel) &&
+      pattern.test(rel) &&
+      ALLOWED_LW_EXTENSIONS.includes(extname(abs))
+    ) {
+      lwFiles.add(abs);
+    }
+  });
+
+  let warnOnce = false;
+  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;
+    }
+    // Warn users about schedule that are less than 60 seconds
+    if (!warnOnce) {
+      warn(
+        'Lightweight monitor schedules will be adjusted to their nearest frequency supported by our synthetics infrastructure.'
+      );
+      warnOnce = true;
+    }
+
+    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();
+      // Filter based on matched tags and name
+      if (!isMatch(config.tags, config.name, options.tags, options.match)) {
+        continue;
+      }
+      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'];
+
+  const alertConfig = parseAlertConfig(config);
+
+  return new Monitor({
+    locations: options.locations,
+    ...config,
+    privateLocations,
+    schedule: schedule || options.schedule,
+    alert: alertConfig,
+  });
+}
+
+export const parseAlertConfig = (config: MonitorConfig) => {
+  if (config['alert.status.enabled'] !== undefined) {
+    const value = config['alert.status.enabled'];
+    delete config['alert.status.enabled'];
+    return {
+      status: {
+        enabled: value,
+      },
+    };
+  }
+  return config.alert;
+};
+
+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.round(scheduleValue / 60);
+        break;
+      case 'm':
+        minutes += scheduleValue;
+        break;
+      case 'h':
+        minutes += scheduleValue * 60;
+        break;
+      case 'd':
+        minutes += scheduleValue * 24 * 60;
+        break;
+    }
+  }
+  return nearestSchedule(minutes);
+}
+
+// Find the nearest schedule that is supported by the platform
+// from the parsed schedule value
+function nearestSchedule(minutes) {
+  let nearest: typeof ALLOWED_SCHEDULES[number] = ALLOWED_SCHEDULES[0];
+  let prev = Math.abs(nearest - minutes);
+  for (let i = 1; i < ALLOWED_SCHEDULES.length; i++) {
+    const curr = Math.abs(ALLOWED_SCHEDULES[i] - minutes);
+    if (curr <= prev) {
+      nearest = ALLOWED_SCHEDULES[i];
+      prev = curr;
+    }
+  }
+  return nearest;
+}

package/src/push/plugin.ts

@@ -0,0 +1,66 @@
+/**
+ * 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 { join } from 'path';
+import * as esbuild from 'esbuild';
+
+// Source of the package - /src, /dist, etc.
+const SOURCE_DIR = join(__dirname, '..');
+
+/**
+ * Avoid importing @elastic/synthetics package from source, this avoids
+ * bundling the synthetics package in tests or when resolved using
+ * absolute paths.
+ * ex: import {journey} from "../../"
+ */
+const isLocalSynthetics = (resolvedPath: string) => {
+  return resolvedPath.startsWith(SOURCE_DIR);
+};
+
+/**
+ * Esbuild Plugin to create separate bundles for all the journeys.
+ * Treats journeys as the entry point and bundles all the dependencies
+ * including the node_modules and ignores bundling the synthetics package
+ * when imported externally or from source.
+ */
+export function SyntheticsBundlePlugin(): esbuild.Plugin {
+  return {
+    name: 'synthetics-bundle-plugin',
+    setup(build) {
+      build.onResolve({ filter: /.*?/ }, async args => {
+        // Ignore entry points as these refer to the journey files
+        if (args.kind === 'entry-point') {
+          return;
+        }
+        const resolvedPath = join(args.resolveDir, args.path);
+        if (isLocalSynthetics(resolvedPath)) {
+          return { external: true };
+        }
+        // Allow esbuild to resolve the module
+        return;
+      });
+    },
+  };
+}

package/src/push/request.ts

@@ -0,0 +1,141 @@
+/**
+ * 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, red, yellow } from 'kleur/colors';
+import type { Dispatcher } from 'undici';
+import { request } from 'undici';
+import { indent, symbols } from '../helpers';
+
+/* eslint-disable @typescript-eslint/no-var-requires */
+const { version } = require('../../package.json');
+
+export type APIRequestOptions = {
+  url: string;
+  method: Dispatcher.HttpMethod;
+  auth: string;
+  body?: string;
+};
+
+export async function sendRequest(options: APIRequestOptions) {
+  return await request(options.url, {
+    method: options.method,
+    body: options.body,
+    headers: {
+      authorization: `ApiKey ${options.auth}`,
+      'content-type': 'application/json',
+      'user-agent': `Elastic/Synthetics ${version}`,
+      'kbn-xsrf': 'true',
+    },
+    headersTimeout: 60 * 1000,
+  });
+}
+
+export async function sendReqAndHandleError<T>(
+  options: APIRequestOptions
+): Promise<T> {
+  const { statusCode, body } = await sendRequest(options);
+  return await (await handleError(statusCode, options.url, body)).json();
+}
+
+// Handle bad status code errors from Kibana API and format the
+// error message to be displayed to the user.
+// returns the response stream if no error is found
+export async function handleError(
+  statusCode: number,
+  url: string,
+  body: Dispatcher.ResponseData['body']
+): Promise<Dispatcher.ResponseData['body']> {
+  if (statusCode === 404) {
+    throw formatNotFoundError(url, await body.text());
+  } else if (!ok(statusCode)) {
+    let parsed: { error: string; message: string };
+    try {
+      parsed = await body.json();
+    } catch (e) {
+      throw formatAPIError(
+        statusCode,
+        'unexpected non-JSON error',
+        await body.text()
+      );
+    }
+    throw formatAPIError(statusCode, parsed.error, parsed.message);
+  }
+
+  return body;
+}
+
+export function ok(statusCode: number) {
+  return statusCode >= 200 && statusCode <= 299;
+}
+
+export type APIMonitorError = {
+  id?: string;
+  reason: string;
+  details: string;
+};
+
+export function formatNotFoundError(url: string, message: string) {
+  return red(
+    bold(
+      `${symbols['failed']} Please check your kibana url: ${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 red(outer);
+}
+
+function formatMonitorError(errors: APIMonitorError[]) {
+  let outer = '';
+  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 formatFailedMonitors(errors: APIMonitorError[]) {
+  const heading = bold(`${symbols['failed']} Error\n`);
+  return red(heading + formatMonitorError(errors));
+}
+
+export function formatStaleMonitors(errors: APIMonitorError[]) {
+  const heading = bold(`${symbols['warning']} Warnings\n`);
+  return yellow(heading + formatMonitorError(errors));
+}