feat: support multi space monitors !! (#1052)

* handle multi spaces

* Update src/push/kibana_api.ts

* PR feedback

* update tests

* update to emit empty spaces

* update tests

* add unit tests

Author: shahzad31

__tests__/core/runner.test.ts

@@ -767,6 +767,7 @@ describe('runner', () => {
         locations: ['united_kingdom'],
         schedule: 3,
         throttling: { download: 5, latency: 20, upload: 3 },
+        spaces: [],
       });
       expect(monitors[1].config).toMatchObject({
         throttling: { latency: 1000 },
@@ -824,6 +825,7 @@ describe('runner', () => {
         alert: { tls: { enabled: true } },
         retestOnFailure: true,
         fields: { area: 'website' },
+        spaces: [],
       });
       expect(monitors[1].config).toMatchObject({
         locations: ['us_east'],

__tests__/push/monitor.test.ts

@@ -33,6 +33,7 @@ import {
   parseAlertConfig,
   parseFields,
   parseSchedule,
+  parseSpaces,
 } from '../../src/push/monitor';
 import { Server } from '../utils/server';
 import { createTestMonitor } from '../utils/test-config';
@@ -85,6 +86,7 @@ describe('Monitors', () => {
       locations: ['europe-west2-a', 'australia-southeast1-a'],
       privateLocations: ['germany'],
       fields: { area: 'website' },
+      spaces: ['test'],
     });
   });
 
@@ -105,8 +107,12 @@ describe('Monitors', () => {
         match: 'test',
       },
       fields: { area: 'website' },
+      spaces: ['test'],
+    });
+    monitor.update({
+      locations: ['brazil'],
+      fields: { env: 'dev' },
     });
-    monitor.update({ locations: ['brazil'], fields: { env: 'dev' } });
     const { schemas: schemas1 } = await buildMonitorSchema([monitor], true);
     expect(schemas1[0].hash).not.toEqual(schemas[0].hash);
     expect(schemas1[0].fields).toEqual({
@@ -497,6 +503,57 @@ heartbeat.monitors:
       `);
 
       const [mon] = await createLightweightMonitors(PROJECT_DIR, {
+        space: 'default',
+        auth: 'foo',
+        params: { foo: 'bar' },
+        kibanaVersion: '8.8.0',
+        locations: ['australia_east'],
+        tags: ['gtag1', 'gtag2'],
+        privateLocations: ['gbaz'],
+        schedule: 10,
+        retestOnFailure: false,
+        spaces: ['default'],
+      });
+
+      expect(mon.config).toEqual({
+        id: 'test-icmp',
+        name: 'test-icmp',
+        locations: ['australia_east'],
+        privateLocations: ['baz'],
+        type: 'icmp',
+        params: { foo: 'bar' },
+        schedule: 5,
+        tags: ['ltag1', 'ltag2'],
+        retestOnFailure: false,
+        fields: {
+          baz: 'qux',
+          foo: 'bar',
+        },
+        spaces: ['default'],
+      });
+    });
+
+    it('supports spaces in config', async () => {
+      await writeHBFile(`
+heartbeat.monitors:
+- type: icmp
+  schedule: @every 5m
+  id: "test-icmp"
+  name: "test-icmp"
+  privateLocations:
+    - baz
+  tags:
+    - ltag1
+    - ltag2
+  fields.foo: bar
+  fields.baz: qux
+  spaces:
+    - space1
+    - space2
+      `);
+
+      const [mon] = await createLightweightMonitors(PROJECT_DIR, {
+        space: 'default',
         auth: 'foo',
         params: { foo: 'bar' },
         kibanaVersion: '8.8.0',
@@ -521,6 +578,7 @@ heartbeat.monitors:
           baz: 'qux',
           foo: 'bar',
         },
+        spaces: ['default', 'space1', 'space2'],
       });
     });
   });
@@ -677,4 +735,58 @@ heartbeat.monitors:
       expect(result).toBeUndefined();
     });
   });
+
+  describe('parseSpaces', () => {
+    it('returns empty object if no spaces are defined', () => {
+      expect(parseSpaces({}, {} as any)).toEqual({});
+      expect(parseSpaces({ spaces: undefined }, {} as any)).toEqual({});
+      expect(parseSpaces({}, { spaces: undefined } as any)).toEqual({});
+    });
+
+    it('merges config and options spaces, including global space', () => {
+      const config = { spaces: ['space1'] };
+      const options = { spaces: ['space2'], space: 'global' };
+      expect(parseSpaces(config, options as any)).toEqual({
+        spaces: ['global', 'space1', 'space2'],
+      });
+    });
+
+    it('handles only config spaces', () => {
+      expect(parseSpaces({ spaces: ['foo'] }, {} as any)).toEqual({
+        spaces: ['foo'],
+      });
+    });
+
+    it('handles only options spaces', () => {
+      expect(parseSpaces({}, { spaces: ['bar'] } as any)).toEqual({
+        spaces: ['bar'],
+      });
+    });
+
+    it('handles global space only', () => {
+      expect(parseSpaces({}, { space: 'default' } as any)).toEqual({});
+    });
+
+    it('deduplicates spaces', () => {
+      const config = { spaces: ['space1', 'space2'] };
+      const options = { spaces: ['space2', 'space3'], space: 'space1' };
+      expect(parseSpaces(config, options as any)).toEqual({
+        spaces: ['space1', 'space2', 'space3'],
+      });
+    });
+
+    it('returns wildcard if present', () => {
+      expect(
+        parseSpaces({ spaces: ['*'] }, {
+          space: 'default',
+          spaces: ['foo'],
+        } as any)
+      ).toEqual({
+        spaces: ['*'],
+      });
+      expect(parseSpaces({}, { spaces: ['*'] } as any)).toEqual({
+        spaces: ['*'],
+      });
+    });
+  });
 });

__tests__/utils/test-config.ts

@@ -43,6 +43,7 @@ export function createTestMonitor(filename: string, type = 'browser') {
     locations: ['united_kingdom', 'australia_east'],
     privateLocations: ['germany'],
     fields: { area: 'website' },
+    spaces: ['test'],
   });
   monitor.setSource({
     file: join(FIXTURES_DIR, filename),

src/common_types.ts

@@ -224,6 +224,7 @@ type BaseArgs = {
   locations?: MonitorConfig['locations'];
   privateLocations?: MonitorConfig['privateLocations'];
   fields?: MonitorConfig['fields'];
+  spaces?: MonitorConfig['spaces'];
 };
 
 export type CliArgs = BaseArgs & {
@@ -263,6 +264,7 @@ export type PushOptions = Partial<ProjectSettings> &
     retestOnFailure?: MonitorConfig['retestOnFailure'];
     enabled?: boolean;
     grepOpts?: GrepOptions;
+    spaces?: MonitorConfig['spaces'];
   };
 
 export type ProjectSettings = {

src/core/runner.ts

@@ -49,6 +49,7 @@ import { PerformanceManager, filterBrowserMessages } from '../plugins';
 import { Gatherer } from './gatherer';
 import { log } from './logger';
 import { Monitor, MonitorConfig } from '../dsl/monitor';
+import { parseSpaces } from '../push/monitor';
 
 type HookType = 'beforeAll' | 'afterAll';
 export type SuiteHooks = Record<HookType, Array<HooksCallback>>;
@@ -443,6 +444,7 @@ export default class Runner implements RunnerInfo {
       retestOnFailure: options.retestOnFailure,
       enabled: options.enabled,
       fields: options.fields,
+      spaces: Array.from(new Set([...(options.spaces ?? []), options.space])),
     });
 
     const monitors: Monitor[] = [];
@@ -465,7 +467,10 @@ export default class Runner implements RunnerInfo {
       // TODO: Fix backwards compatibility with 1.14 and prior
       (journey.cb ?? journey.callback)({ params: options.params } as any);
       const monitor = journey.monitor ?? journey?._getMonitor();
-      monitor.update(this.#monitor?.config);
+      monitor.update({
+        ...this.#monitor?.config,
+        ...parseSpaces(monitor.config, options),
+      });
       if (!monitor.isMatch(options.grepOpts?.match, options.grepOpts?.tags)) {
         continue;
       }

src/dsl/monitor.ts

@@ -77,6 +77,10 @@ export type MonitorConfig = {
    * By default, the monitor will be retested on failure
    */
   retestOnFailure?: boolean;
+  /**
+   * The kibana spaces where the monitor will be visible.
+   */
+  spaces?: string[];
 };
 
 type MonitorFilter = {

src/push/index.ts

@@ -75,6 +75,7 @@ export async function push(monitors: Monitor[], options: PushOptions) {
   if (duplicates.size > 0) {
     throw error(formatDuplicateError(duplicates));
   }
+
   progress(
     `Pushing monitors for '${options.id}' project in kibana '${options.space}' space`
   );

src/push/monitor.ts

@@ -293,6 +293,7 @@ export function buildMonitorFromYaml(
     tags: options.tags,
     fields: parseFields(config, options.fields),
     ...normalizeConfig(config),
+    ...parseSpaces(config, options),
     retestOnFailure,
     privateLocations,
     schedule:
@@ -335,6 +336,27 @@ export const parseAlertConfig = (
   return Object.keys(result).length > 0 ? result : undefined;
 };
 
+export const parseSpaces = (config: MonitorConfig, options: PushOptions) => {
+  const baseSpaces = [...(config.spaces ?? []), ...(options.spaces ?? [])];
+  if (!baseSpaces.length) {
+    // If no spaces are defined, we return an empty object
+    return {};
+  }
+
+  // If the user has provided a global space, merge it with the monitor spaces
+  const spaces = Array.from(
+    options.space
+      ? new Set([options.space, ...baseSpaces])
+      : new Set(baseSpaces)
+  );
+
+  if (spaces.includes('*')) {
+    // If the user has provided a wildcard space, we should not override it with the global space
+    return { spaces: ['*'] };
+  }
+  return { spaces };
+};
+
 export const parseFields = (
   config: MonitorConfig,
   gFields?: Record<string, string>