[Synthetics] Template string syntax breaks inline monitors when running against the service

x-pack/plugins/synthetics/common/runtime_types/monitor_management/monitor_types.ts

@@ -243,6 +243,8 @@ export const BrowserSensitiveSimpleFieldsCodec = t.intersection([
   CommonFieldsCodec,
 ]);
 
+export type BrowserSensitiveSimpleFields = t.TypeOf<typeof BrowserSensitiveSimpleFieldsCodec>;
+
 export const ThrottlingConfigValueCodec = t.interface({
   download: t.string,
   upload: t.string,

x-pack/plugins/synthetics/server/common/mem_writable.test.ts

@@ -0,0 +1,54 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { inlineToProjectZip, MemWritable } from './mem_writable';
+
+describe('MemWritable', () => {
+  it('should write chunks to the buffer', async () => {
+    const memWritable = new MemWritable();
+
+    const chunk1 = `step('goto', () => page.goto('https://elastic.co'));`;
+    const chunk2 = `step('throw error', () => { throw new Error('error'); });`;
+    const expectedBuffer = Buffer.from(chunk1 + chunk2);
+
+    await new Promise<void>((resolve, reject) => {
+      memWritable.write(Buffer.from(chunk1), (err) => {
+        if (err) {
+          reject(err);
+        }
+        expect(memWritable.buffer).toEqual(Buffer.from(chunk1));
+        resolve();
+      });
+    });
+    await new Promise<void>((resolve, reject) => {
+      memWritable.write(Buffer.from(chunk2), (err) => {
+        if (err) {
+          reject(err);
+        }
+        resolve();
+      });
+    });
+    expect(memWritable.buffer).toEqual(expectedBuffer);
+  });
+});
+
+describe('inlineToProjectZip', () => {
+  it('should return base64 encoded zip data', async () => {
+    const inlineJourney = `
+step('goto', () => page.goto('https://elastic.co'));
+step('throw error', () => { throw new Error('error'); });
+`;
+    const monitorId = 'testMonitorId';
+    const logger = jest.fn();
+
+    // @ts-expect-error not checking logger functionality
+    const result = await inlineToProjectZip(inlineJourney, monitorId, logger);
+
+    // zip is not deterministic, so we can't check the exact value
+    expect(result.length).toBeGreaterThan(0);
+  });
+});

x-pack/plugins/synthetics/server/common/mem_writable.ts

@@ -0,0 +1,70 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { Logger } from '@kbn/logging';
+import archiver from 'archiver';
+import { Writable, WritableOptions } from 'node:stream';
+
+export class MemWritable extends Writable {
+  private _buffer: Buffer;
+  constructor(opts?: WritableOptions) {
+    super(opts);
+    this._buffer = Buffer.from('');
+  }
+
+  public get buffer(): Buffer {
+    return this._buffer;
+  }
+
+  _write(
+    chunk: any,
+    _encoding: BufferEncoding,
+    callback: (error?: Error | null | undefined) => void
+  ): void {
+    try {
+      this._buffer = Buffer.concat([this._buffer, chunk]);
+      callback();
+    } catch (e) {
+      callback(e);
+    }
+  }
+}
+
+function wrapInlineInProject(inlineJourney: string) {
+  return `import { journey, step, expect } from '@elastic/synthetics';
+
+journey('inline', ({ page, context, browser, params, request }) => {
+  ${inlineJourney}
+});
+`;
+}
+
+export async function inlineToProjectZip(
+  inlineJourney: string,
+  monitorId: string,
+  logger: Logger
+): Promise<string> {
+  const mWriter = new MemWritable();
+  try {
+    await new Promise((resolve, reject) => {
+      const archive = archiver('zip', {
+        zlib: { level: 9 },
+      });
+      archive.on('error', reject);
+      mWriter.on('close', resolve);
+      archive.pipe(mWriter);
+      archive.append(wrapInlineInProject(inlineJourney), {
+        name: 'inline.journey.ts',
+      });
+      archive.finalize();
+    });
+  } catch (e) {
+    logger.error(`Failed to create zip for inline monitor ${monitorId}`);
+    throw e;
+  }
+  return mWriter.buffer.toString('base64');
+}

x-pack/plugins/synthetics/server/routes/monitor_cruds/add_monitor.test.ts

@@ -0,0 +1,149 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { ConfigKey, SyntheticsMonitor } from '../../../common/runtime_types';
+import { hydrateMonitorFields } from './add_monitor';
+
+describe('hydrateMonitorFields', () => {
+  it('creates expected zip b64 project field value for inline browser monitor', async () => {
+    const normalizedMonitor: SyntheticsMonitor = {
+      // @ts-expect-error extra field
+      type: 'browser',
+      // @ts-expect-error extra field
+      form_monitor_type: 'multistep',
+      enabled: true,
+      alert: { status: { enabled: true }, tls: { enabled: true } },
+      // @ts-expect-error extra field
+      schedule: { unit: 'm', number: '10' },
+      'service.name': '',
+      config_id: '',
+      tags: [],
+      timeout: null,
+      name: 'test-once-more',
+      locations: [{ id: 'dev', label: 'Dev Service', isServiceManaged: true }],
+      namespace: 'default',
+      // @ts-expect-error extra field
+      origin: 'ui',
+      journey_id: '',
+      hash: '',
+      id: '',
+      params: '',
+      max_attempts: 2,
+      project_id: '',
+      playwright_options: '',
+      __ui: { script_source: { is_generated_script: false, file_name: '' } },
+      'url.port': null,
+      'source.inline.script': `step('goto', () => page.goto('https://elastic.co'))
+step('fail', () => {
+  throw Error('fail');
+})`,
+      'source.project.content': '',
+      playwright_text_assertion: '',
+      urls: '',
+      screenshots: 'on',
+      synthetics_args: [],
+      'filter_journeys.match': '',
+      'filter_journeys.tags': [],
+      ignore_https_errors: false,
+      throttling: {
+        value: { download: '5', upload: '3', latency: '20' },
+        id: 'default',
+        label: 'Default',
+      },
+      'ssl.certificate_authorities': '',
+      'ssl.certificate': '',
+      'ssl.key': '',
+      'ssl.key_passphrase': '',
+      'ssl.verification_mode': 'full',
+      'ssl.supported_protocols': ['TLSv1.1', 'TLSv1.2', 'TLSv1.3'],
+    };
+
+    const hydratedMonitor = await hydrateMonitorFields({
+      normalizedMonitor,
+      newMonitorId: 'testMonitorId',
+      routeContext: {
+        // @ts-expect-error not checking request functionality
+        request: {
+          query: {
+            preserve_namespace: true,
+          },
+        },
+        server: {
+          // @ts-expect-error not checking logger functionality
+          logger: jest.fn(),
+        },
+      },
+    });
+
+    expect(hydratedMonitor[ConfigKey.SOURCE_PROJECT_CONTENT]).toBeDefined();
+    // zip is not deterministic, so we can't check the exact value
+    expect(hydratedMonitor[ConfigKey.SOURCE_PROJECT_CONTENT]).length.toBeGreaterThan(0);
+  });
+
+  it('does not add b64 zip data to lightweight monitors', async () => {
+    const newMonitorId = 'testMonitorId';
+    const routeContext = {
+      request: {
+        query: {
+          preserve_namespace: true,
+        },
+      },
+      server: {
+        logger: jest.fn(),
+      },
+    };
+    const normalizedMonitor: SyntheticsMonitor = {
+      // @ts-expect-error extra field
+      type: 'tcp',
+      // @ts-expect-error extra field
+      form_monitor_type: 'tcp',
+      enabled: true,
+      alert: { status: { enabled: true }, tls: { enabled: true } },
+      // @ts-expect-error extra field
+      schedule: { number: '3', unit: 'm' },
+      'service.name': '',
+      config_id: '',
+      tags: [],
+      timeout: '16',
+      name: 'tcp://google.com:80',
+      locations: [{ id: 'dev', label: 'Dev Service', isServiceManaged: true }],
+      namespace: 'default',
+      // @ts-expect-error extra field
+      origin: 'ui',
+      journey_id: '',
+      hash: '',
+      id: '',
+      params: '',
+      max_attempts: 2,
+      __ui: { is_tls_enabled: false },
+      hosts: 'tcp://google.com:80',
+      urls: '',
+      'url.port': null,
+      proxy_url: '',
+      proxy_use_local_resolver: false,
+      'check.receive': '',
+      'check.send': '',
+      mode: 'any',
+      ipv4: true,
+      ipv6: true,
+      'ssl.certificate_authorities': '',
+      'ssl.certificate': '',
+      'ssl.key': '',
+      'ssl.key_passphrase': '',
+      'ssl.verification_mode': 'full',
+      'ssl.supported_protocols': ['TLSv1.1', 'TLSv1.2', 'TLSv1.3'],
+    };
+    const hydratedMonitor = await hydrateMonitorFields({
+      normalizedMonitor,
+      newMonitorId,
+      // @ts-expect-error not checking routeContext functionality
+      routeContext,
+    });
+
+    expect(hydratedMonitor[ConfigKey.SOURCE_PROJECT_CONTENT]).toEqual('');
+  });
+});

x-pack/plugins/synthetics/server/routes/monitor_cruds/add_monitor.ts

@@ -24,6 +24,7 @@ import {
   MonitorFields,
   SyntheticsMonitor,
   EncryptedSyntheticsMonitorAttributes,
+  BrowserSensitiveSimpleFields,
 } from '../../../common/runtime_types';
 import { formatKibanaNamespace } from '../../synthetics_service/formatters/private_formatters';
 import { getPrivateLocations } from '../../synthetics_service/get_private_locations';
@@ -38,6 +39,7 @@ import { sendTelemetryEvents, formatTelemetryEvent } from '../telemetry/monitor_
 import { formatSecrets } from '../../synthetics_service/utils/secrets';
 import { deleteMonitor } from './delete_monitor';
 import { mapSavedObjectToMonitor } from './helper';
+import { inlineToProjectZip } from '../../common/mem_writable';
 
 export const addSyntheticsMonitorRoute: SyntheticsRestApiRouteFactory = () => ({
   method: 'POST',
@@ -137,7 +139,7 @@ export const createNewSavedObjectMonitor = async ({
   );
 };
 
-export const hydrateMonitorFields = ({
+export const hydrateMonitorFields = async ({
   newMonitorId,
   normalizedMonitor,
   routeContext,
@@ -152,13 +154,21 @@ export const hydrateMonitorFields = ({
     string,
     { preserve_namespace?: boolean }
   >;
+
+  const inlineSource = (normalizedMonitor as BrowserSensitiveSimpleFields)?.[
+    ConfigKey.SOURCE_INLINE
+  ] as string | undefined;
+
   return {
     ...normalizedMonitor,
     [ConfigKey.MONITOR_QUERY_ID]: normalizedMonitor[ConfigKey.CUSTOM_HEARTBEAT_ID] || newMonitorId,
     [ConfigKey.CONFIG_ID]: newMonitorId,
     [ConfigKey.NAMESPACE]: preserveNamespace
       ? normalizedMonitor[ConfigKey.NAMESPACE]
       : getMonitorNamespace(server, request, normalizedMonitor[ConfigKey.NAMESPACE]),
+    [ConfigKey.SOURCE_PROJECT_CONTENT]: !!inlineSource
+      ? await inlineToProjectZip(inlineSource, newMonitorId, server.logger)
+      : '',
   };
 };
 
@@ -177,7 +187,7 @@ export const syncNewMonitor = async ({
   const newMonitorId = id ?? uuidV4();
 
   let monitorSavedObject: SavedObject<EncryptedSyntheticsMonitorAttributes> | null = null;
-  const monitorWithNamespace = hydrateMonitorFields({
+  const monitorWithNamespace = await hydrateMonitorFields({
     normalizedMonitor,
     routeContext,
     newMonitorId,