[scout] improve logs readability by using unique logger context per playwright worker

src/platform/packages/shared/kbn-scout/src/common/services/logger.ts

@@ -10,8 +10,8 @@
 import { ToolingLog } from '@kbn/tooling-log';
 
 export class ScoutLogger extends ToolingLog {
-  constructor() {
-    super({ level: 'verbose', writeTo: process.stdout }, { context: 'scout' });
+  constructor(workerContext: string) {
+    super({ level: 'verbose', writeTo: process.stdout }, { context: workerContext });
     this.serviceLoaded('logger');
   }
 
@@ -20,20 +20,28 @@ export class ScoutLogger extends ToolingLog {
    * @param name unique name of the service
    */
   public serviceLoaded(name: string) {
-    this.debug(`[service] ${name}`);
+    this.debug(`[${name}] loaded`);
+  }
+
+  /**
+   * Used to log a message for a service/fixture
+   */
+  public serviceMessage(name: string, message: string) {
+    this.debug(`[${name}] ${name}`);
   }
 }
 
-let loggerInstance: ScoutLogger | null = null;
+const loggerInstances = new Map<string, ScoutLogger>();
 
 /**
- * Singleton logger instance to share across the Scout components
- * @returns {ScoutLogger}
+ * Singleton logger instance for specific worker to share across the Scout components
+ * @param workerContext logger context, e.g. `scout-worker-1`; default is `scout`
+ * @returns {ScoutLogger} logger instance
  */
-export function getLogger(): ScoutLogger {
-  if (!loggerInstance) {
-    loggerInstance = new ScoutLogger();
+export function getLogger(workerContext: string = 'scout'): ScoutLogger {
+  if (!loggerInstances.has(workerContext)) {
+    loggerInstances.set(workerContext, new ScoutLogger(workerContext));
   }
 
-  return loggerInstance;
+  return loggerInstances.get(workerContext)!;
 }

src/platform/packages/shared/kbn-scout/src/playwright/fixtures/parallel_run_fixtures.ts

@@ -25,9 +25,11 @@ import {
   validateTagsFixture,
 } from './test';
 import type { BrowserAuthFixture, ScoutPage, PageObjects } from './test';
+import { logParallelFixture } from './worker/log';
 
 export const scoutParallelFixtures = mergeTests(
   // worker scope fixtures
+  logParallelFixture,
   coreWorkerFixtures,
   scoutSpaceParallelFixture,
   apiFixtures,

src/platform/packages/shared/kbn-scout/src/playwright/fixtures/single_thread_fixtures.ts

@@ -33,10 +33,12 @@ import {
   validateTagsFixture,
 } from './test';
 import type { BrowserAuthFixture, ScoutPage, PageObjects } from './test';
+import { logFixture } from './worker/log';
 export type { ScoutPage, PageObjects } from './test';
 
 export const scoutFixtures = mergeTests(
   // worker scope fixtures
+  logFixture,
   coreWorkerFixtures,
   esArchiverFixture,
   uiSettingsFixture,

src/platform/packages/shared/kbn-scout/src/playwright/fixtures/test/page_objects/parallel.ts

@@ -25,9 +25,9 @@ export const pageObjectsParallelFixture = scoutPageParallelFixture.extend<
   },
   { scoutSpace: ScoutSpaceParallelFixture }
 >({
-  pageObjects: async ({ page, log, scoutSpace }, use) => {
+  pageObjects: async ({ page, log }, use) => {
     const corePageObjects = createCorePageObjects(page);
-    log.serviceLoaded(`pageObjects:${scoutSpace.id}`);
+    log.serviceLoaded(`pageObjects`);
     await use(corePageObjects);
   },
 });

src/platform/packages/shared/kbn-scout/src/playwright/fixtures/test/scout_page/parallel.ts

@@ -33,7 +33,7 @@ export const scoutPageParallelFixture = base.extend<
     extendedPage.gotoApp = (appName: string, pathOptions?: PathOptions) =>
       page.goto(kbnUrl.app(appName, { space: scoutSpace.id, pathOptions }));
 
-    log.serviceLoaded(`scoutPage:${scoutSpace.id}`);
+    log.serviceLoaded(`scoutPage`);
     await use(extendedPage);
   },
 });

src/platform/packages/shared/kbn-scout/src/playwright/fixtures/worker/core_fixtures.ts

@@ -14,18 +14,16 @@ import {
   createKbnUrl,
   getEsClient,
   getKbnClient,
-  getLogger,
   createSamlSessionManager,
   createScoutConfig,
   KibanaUrl,
 } from '../../../common/services';
-import { ScoutTestOptions } from '../../types';
-import { ScoutTestConfig } from '.';
-import { ScoutLogger } from '../../../common';
+import type { ScoutTestOptions } from '../../types';
+import type { ScoutTestConfig } from '.';
+import type { ScoutLogger } from './log';
 
 // re-export to import types from '@kbn-scout'
 export type { KbnClient, SamlSessionManager } from '@kbn/test';
-export type { ScoutLogger } from '../../../common';
 export type { Client as EsClient } from '@elastic/elasticsearch';
 export type { KibanaUrl } from '../../../common/services/kibana_url';
 export type { ScoutTestConfig } from '../../../types';
@@ -48,15 +46,6 @@ export const coreWorkerFixtures = base.extend<
     samlAuth: SamlSessionManager;
   }
 >({
-  // Provides a scoped logger instance for each worker. This logger is shared across
-  // all other fixtures within the worker scope.
-  log: [
-    ({}, use) => {
-      use(getLogger());
-    },
-    { scope: 'worker' },
-  ],
-
   /**
    * Loads the test server configuration from the source file based on local or cloud
    * target, located by default in '.scout/servers' directory. It supplies Playwright

src/platform/packages/shared/kbn-scout/src/playwright/fixtures/worker/index.ts

@@ -9,7 +9,6 @@
 
 export { coreWorkerFixtures } from './core_fixtures';
 export type {
-  ScoutLogger,
   ScoutTestConfig,
   KibanaUrl,
   EsClient,
@@ -31,3 +30,6 @@ export type { ApiFixtures, ApiParallelWorkerFixtures } from './apis';
 
 export { synthtraceFixture } from './synthtrace';
 export type { SynthtraceFixture } from './synthtrace';
+
+export { logFixture, logParallelFixture } from './log';
+export type { ScoutLogger } from './log';

src/platform/packages/shared/kbn-scout/src/playwright/fixtures/worker/log/index.ts

@@ -0,0 +1,12 @@
+/*
+ * 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", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+export { logFixture } from './single_thread';
+export { logParallelFixture } from './parallel';
+export type { ScoutLogger } from '../../../../common';

src/platform/packages/shared/kbn-scout/src/playwright/fixtures/worker/log/parallel.ts

@@ -0,0 +1,32 @@
+/*
+ * 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", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+import { test as base } from '@playwright/test';
+import { getLogger } from '../../../../common/services';
+import { ScoutLogger } from '../../../../common';
+
+/**
+ * Provides a scoped logger instance for each worker. This logger is shared across
+ * all other fixtures within the worker scope. This fixture is used in the parallel
+ * test execution mode to better diffirentiate between logs from different workers: `scout-1`, `scout-2`, etc.
+ */
+export const logParallelFixture = base.extend<
+  {},
+  {
+    log: ScoutLogger;
+  }
+>({
+  log: [
+    ({}, use, workerInfo) => {
+      const loggerContext = `scout-worker-${workerInfo.parallelIndex + 1}`;
+      use(getLogger(loggerContext));
+    },
+    { scope: 'worker' },
+  ],
+});

src/platform/packages/shared/kbn-scout/src/playwright/fixtures/worker/log/single_thread.ts

@@ -0,0 +1,30 @@
+/*
+ * 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", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+import { test as base } from '@playwright/test';
+import { getLogger } from '../../../../common/services';
+import { ScoutLogger } from '../../../../common';
+
+/**
+ * Provides a scoped logger instance for each worker. This logger is shared across
+ * all other fixtures within the worker scope.
+ */
+export const logFixture = base.extend<
+  {},
+  {
+    log: ScoutLogger;
+  }
+>({
+  log: [
+    ({}, use) => {
+      use(getLogger('scout-worker'));
+    },
+    { scope: 'worker' },
+  ],
+});

src/platform/packages/shared/kbn-scout/src/playwright/fixtures/worker/scout_space/parallel.ts

@@ -19,46 +19,42 @@ export const scoutSpaceParallelFixture = coreWorkerFixtures.extend<
 >({
   scoutSpace: [
     async ({ log, kbnClient }, use, workerInfo) => {
-      const spaceId = `test-space-${workerInfo.workerIndex}`;
+      const spaceId = `test-space-${workerInfo.parallelIndex + 1}`;
       const spacePayload = {
         id: spaceId,
         name: spaceId,
         disabledFeatures: [],
       };
-      await measurePerformanceAsync(log, `scoutSpace:${spaceId} 'spaces.create'`, async () => {
+      await measurePerformanceAsync(log, `${spaceId}: 'spaces.create'`, async () => {
         return kbnClient.spaces.create(spacePayload);
       });
 
       // cache saved objects ids in space
       const savedObjectsCache = new Map<string, string>();
 
       const load = async (path: string) => {
-        return measurePerformanceAsync(
-          log,
-          `scoutSpace:${spaceId} 'savedObjects.load'`,
-          async () => {
-            const response = await kbnClient.importExport.load(path, {
-              space: spaceId,
-              // will create new copies of saved objects with unique ids
-              createNewCopies: true,
-            });
+        return measurePerformanceAsync(log, `${spaceId}: 'savedObjects.load'`, async () => {
+          const response = await kbnClient.importExport.load(path, {
+            space: spaceId,
+            // will create new copies of saved objects with unique ids
+            createNewCopies: true,
+          });
 
-            const imported = (response.successResults as ImportSavedObjects[]).map(
-              (r: { type: string; destinationId: string; meta: { title: string } }) => {
-                return { id: r.destinationId, type: r.type, title: r.meta.title };
-              }
-            );
+          const imported = (response.successResults as ImportSavedObjects[]).map(
+            (r: { type: string; destinationId: string; meta: { title: string } }) => {
+              return { id: r.destinationId, type: r.type, title: r.meta.title };
+            }
+          );
 
-            imported.forEach((so) => savedObjectsCache.set(so.title, so.id));
+          imported.forEach((so) => savedObjectsCache.set(so.title, so.id));
 
-            return imported;
-          }
-        );
+          return imported;
+        });
       };
       const cleanStandardList = async () => {
         return measurePerformanceAsync(
           log,
-          `scoutSpace:${spaceId} 'savedObjects.cleanStandardList'`,
+          `${spaceId}: 'savedObjects.cleanStandardList'`,
           async () => {
             savedObjectsCache.clear();
             await kbnClient.savedObjects.cleanStandardList({
@@ -70,7 +66,7 @@ export const scoutSpaceParallelFixture = coreWorkerFixtures.extend<
       const setDefaultIndex = async (dataViewName: string) => {
         return measurePerformanceAsync(
           log,
-          `scoutSpace:${spaceId} 'savedObjects.setDefaultIndex'`,
+          `${spaceId}: 'savedObjects.setDefaultIndex'`,
           async () => {
             if (savedObjectsCache.has(dataViewName)) {
               return kbnClient.uiSettings.update(
@@ -91,31 +87,23 @@ export const scoutSpaceParallelFixture = coreWorkerFixtures.extend<
         });
       };
       const unset = async (...keys: string[]) => {
-        return measurePerformanceAsync(
-          log,
-          `scoutSpace:${spaceId} 'uiSettings.unset'`,
-          async () => {
-            return Promise.all(
-              keys.map((key) => kbnClient.uiSettings.unset(key, { space: spaceId }))
-            );
-          }
-        );
+        return measurePerformanceAsync(log, `${spaceId}: 'uiSettings.unset'`, async () => {
+          return Promise.all(
+            keys.map((key) => kbnClient.uiSettings.unset(key, { space: spaceId }))
+          );
+        });
       };
       const setDefaultTime = async ({ from, to }: { from: string; to: string }) => {
-        return measurePerformanceAsync(
-          log,
-          `scoutSpace:${spaceId} 'uiSettings.setDefaultTime'`,
-          async () => {
-            const utcFrom = isValidUTCDate(from) ? from : formatTime(from);
-            const untcTo = isValidUTCDate(to) ? to : formatTime(to);
-            return kbnClient.uiSettings.update(
-              {
-                'timepicker:timeDefaults': `{ "from": "${utcFrom}", "to": "${untcTo}"}`,
-              },
-              { space: spaceId }
-            );
-          }
-        );
+        return measurePerformanceAsync(log, `${spaceId}: 'uiSettings.setDefaultTime'`, async () => {
+          const utcFrom = isValidUTCDate(from) ? from : formatTime(from);
+          const utcTo = isValidUTCDate(to) ? to : formatTime(to);
+          return kbnClient.uiSettings.update(
+            {
+              'timepicker:timeDefaults': `{ "from": "${utcFrom}", "to": "${utcTo}"}`,
+            },
+            { space: spaceId }
+          );
+        });
       };
 
       const savedObjects = {
@@ -130,11 +118,12 @@ export const scoutSpaceParallelFixture = coreWorkerFixtures.extend<
         setDefaultTime,
       };
 
-      log.serviceLoaded(`scoutSpace:${spaceId}`);
+      log.serviceMessage('scoutSpace', `New Kibana space '${spaceId}' created`);
       await use({ savedObjects, uiSettings, id: spaceId });
 
       // Cleanup space after tests via API call
-      await measurePerformanceAsync(log, `scoutSpace:${spaceId} 'space.delete'`, async () => {
+      await measurePerformanceAsync(log, `${spaceId} 'space.delete'`, async () => {
+        log.debug(`Deleting space ${spaceId}`);
         return kbnClient.spaces.delete(spaceId);
       });
     },