Flexible EBT Performance Metric Schema

src/core/public/core_system.test.mocks.ts

@@ -31,11 +31,6 @@ jest.doMock('@kbn/core-analytics-browser-internal', () => ({
   AnalyticsService: AnalyticsServiceConstructor,
 }));
 
-export const fetchOptionalMemoryInfoMock = jest.fn();
-jest.doMock('./fetch_optional_memory_info', () => ({
-  fetchOptionalMemoryInfo: fetchOptionalMemoryInfoMock,
-}));
-
 export const MockInjectedMetadataService = injectedMetadataServiceMock.create();
 export const InjectedMetadataServiceConstructor = jest
   .fn()

src/core/public/core_system.test.ts

@@ -37,10 +37,18 @@ import {
   AnalyticsServiceConstructor,
   MockAnalyticsService,
   analyticsServiceStartMock,
-  fetchOptionalMemoryInfoMock,
 } from './core_system.test.mocks';
 
 import { CoreSystem } from './core_system';
+import {
+  KIBANA_LOADED_EVENT,
+  LOAD_START,
+  LOAD_BOOTSTRAP_START,
+  LOAD_CORE_CREATED,
+  LOAD_FIRST_NAV,
+  LOAD_SETUP_DONE,
+  LOAD_START_DONE,
+} from './utils';
 
 jest.spyOn(CoreSystem.prototype, 'stop');
 
@@ -75,12 +83,28 @@ beforeEach(() => {
   window.performance.clearMarks = jest.fn();
   window.performance.getEntriesByName = jest.fn().mockReturnValue([
     {
-      detail: 'load_started',
-      startTime: 456,
+      detail: LOAD_START,
+      startTime: 111,
+    },
+    {
+      detail: LOAD_BOOTSTRAP_START,
+      startTime: 222,
     },
     {
-      detail: 'bootstrap_started',
-      startTime: 123,
+      detail: LOAD_CORE_CREATED,
+      startTime: 333,
+    },
+    {
+      detail: LOAD_SETUP_DONE,
+      startTime: 444,
+    },
+    {
+      detail: LOAD_START_DONE,
+      startTime: 555,
+    },
+    {
+      detail: LOAD_FIRST_NAV,
+      startTime: 666,
     },
   ]);
 });
@@ -251,34 +275,41 @@ describe('#start()', () => {
   it('reports the event Loaded Kibana and clears marks', async () => {
     await startCore();
     expect(analyticsServiceStartMock.reportEvent).toHaveBeenCalledTimes(1);
-    expect(analyticsServiceStartMock.reportEvent).toHaveBeenCalledWith('Loaded Kibana', {
+    expect(analyticsServiceStartMock.reportEvent).toHaveBeenCalledWith(KIBANA_LOADED_EVENT, {
       kibana_version: '1.2.3',
-      load_started: 456,
-      bootstrap_started: 123,
       protocol: 'http:',
+      key1: LOAD_START,
+      key2: LOAD_BOOTSTRAP_START,
+      key3: LOAD_CORE_CREATED,
+      key4: LOAD_SETUP_DONE,
+      key5: LOAD_START_DONE,
+      value1: 111,
+      value2: 222,
+      value3: 333,
+      value4: 444,
+      value5: 555,
+      duration: 666,
     });
 
     expect(window.performance.clearMarks).toHaveBeenCalledTimes(1);
   });
 
   it('reports the event Loaded Kibana (with memory)', async () => {
-    fetchOptionalMemoryInfoMock.mockReturnValue({
-      load_started: 456,
-      bootstrap_started: 123,
-      memory_js_heap_size_limit: 3,
-      memory_js_heap_size_total: 2,
-      memory_js_heap_size_used: 1,
-    });
-
     await startCore();
     expect(analyticsServiceStartMock.reportEvent).toHaveBeenCalledTimes(1);
-    expect(analyticsServiceStartMock.reportEvent).toHaveBeenCalledWith('Loaded Kibana', {
-      load_started: 456,
-      bootstrap_started: 123,
+    expect(analyticsServiceStartMock.reportEvent).toHaveBeenCalledWith(KIBANA_LOADED_EVENT, {
       kibana_version: '1.2.3',
-      memory_js_heap_size_limit: 3,
-      memory_js_heap_size_total: 2,
-      memory_js_heap_size_used: 1,
+      duration: 666,
+      key1: LOAD_START,
+      key2: LOAD_BOOTSTRAP_START,
+      key3: LOAD_CORE_CREATED,
+      key4: LOAD_SETUP_DONE,
+      key5: LOAD_START_DONE,
+      value1: 111,
+      value2: 222,
+      value3: 333,
+      value4: 444,
+      value5: 555,
       protocol: 'http:',
     });
   });

src/core/public/core_system.ts

@@ -36,8 +36,17 @@ import { SavedObjectsService } from './saved_objects';
 import { IntegrationsService } from './integrations';
 import { CoreApp } from './core_app';
 import type { InternalApplicationSetup, InternalApplicationStart } from './application/types';
-import { fetchOptionalMemoryInfo } from './fetch_optional_memory_info';
-import { KBN_LOAD_MARKS } from './utils';
+import {
+  KBN_LOAD_MARKS,
+  LOAD_SETUP_DONE,
+  LOAD_START_DONE,
+  KIBANA_LOADED_EVENT,
+  LOAD_CORE_CREATED,
+  PERFORMANCE_METRIC_EVENT_SCHEMA,
+  LOAD_FIRST_NAV,
+  LOAD_BOOTSTRAP_START,
+  LOAD_START,
+} from './utils';
 
 interface Params {
   rootDomElement: HTMLElement;
@@ -129,12 +138,12 @@ export class CoreSystem {
     this.coreApp = new CoreApp(this.coreContext);
 
     performance.mark(KBN_LOAD_MARKS, {
-      detail: 'core_created',
+      detail: LOAD_CORE_CREATED,
     });
   }
 
-  private getLoadMarksInfo() {
-    if (!performance) return [];
+  private getLoadMarksInfo(): Record<string, number> {
+    if (!performance) return {};
     const reportData: Record<string, number> = {};
     const marks = performance.getEntriesByName(KBN_LOAD_MARKS);
     for (const mark of marks) {
@@ -145,11 +154,23 @@ export class CoreSystem {
   }
 
   private reportKibanaLoadedEvent(analytics: AnalyticsServiceStart) {
-    analytics.reportEvent('Loaded Kibana', {
+    const timing = this.getLoadMarksInfo();
+    analytics.reportEvent(KIBANA_LOADED_EVENT, {
       kibana_version: this.coreContext.env.packageInfo.version,
       protocol: window.location.protocol,
-      ...fetchOptionalMemoryInfo(),
-      ...this.getLoadMarksInfo(),
+      duration: timing[LOAD_FIRST_NAV],
+      // @ts-expect-error 2339
+      ...performance.memory,
+      key1: LOAD_START,
+      value1: timing[LOAD_START],
+      key2: LOAD_BOOTSTRAP_START,
+      value2: timing[LOAD_BOOTSTRAP_START],
+      key3: LOAD_CORE_CREATED,
+      value3: timing[LOAD_CORE_CREATED],
+      key4: LOAD_SETUP_DONE,
+      value4: timing[LOAD_SETUP_DONE],
+      key5: LOAD_START_DONE,
+      value5: timing[LOAD_START_DONE],
     });
     performance.clearMarks(KBN_LOAD_MARKS);
   }
@@ -200,7 +221,7 @@ export class CoreSystem {
       await this.plugins.setup(core);
 
       performance.mark(KBN_LOAD_MARKS, {
-        detail: 'setup_done',
+        detail: LOAD_SETUP_DONE,
       });
 
       return { fatalErrors: this.fatalErrorsSetup };
@@ -300,13 +321,13 @@ export class CoreSystem {
       });
 
       performance.mark(KBN_LOAD_MARKS, {
-        detail: 'start_done',
+        detail: LOAD_START_DONE,
       });
 
       // Wait for the first app navigation to report Kibana Loaded
       firstValueFrom(application.currentAppId$.pipe(filter(Boolean))).then(() => {
         performance.mark(KBN_LOAD_MARKS, {
-          detail: 'first_app_nav',
+          detail: LOAD_FIRST_NAV,
         });
         this.reportKibanaLoadedEvent(analytics);
       });
@@ -344,51 +365,13 @@ export class CoreSystem {
 
   private registerLoadedKibanaEventType(analytics: AnalyticsServiceSetup) {
     analytics.registerEventType({
-      eventType: 'Loaded Kibana',
+      eventType: KIBANA_LOADED_EVENT,
       schema: {
+        ...PERFORMANCE_METRIC_EVENT_SCHEMA,
         kibana_version: {
           type: 'keyword',
           _meta: { description: 'The version of Kibana' },
         },
-        memory_js_heap_size_limit: {
-          type: 'long',
-          _meta: { description: 'The maximum size of the heap', optional: true },
-        },
-        memory_js_heap_size_total: {
-          type: 'long',
-          _meta: { description: 'The total size of the heap', optional: true },
-        },
-        memory_js_heap_size_used: {
-          type: 'long',
-          _meta: { description: 'The used size of the heap', optional: true },
-        },
-        load_started: {
-          type: 'long',
-          _meta: { description: 'When the render template starts loading assets', optional: true },
-        },
-        bootstrap_started: {
-          type: 'long',
-          _meta: { description: 'When kbnBootstrap callback is called', optional: true },
-        },
-        core_created: {
-          type: 'long',
-          _meta: { description: 'When core system is created', optional: true },
-        },
-        setup_done: {
-          type: 'long',
-          _meta: { description: 'When core system setup is complete', optional: true },
-        },
-        start_done: {
-          type: 'long',
-          _meta: { description: 'When core system start is complete', optional: true },
-        },
-        first_app_nav: {
-          type: 'long',
-          _meta: {
-            description: 'When the application emits the first app navigation',
-            optional: true,
-          },
-        },
         protocol: {
           type: 'keyword',
           _meta: {

src/core/public/index.ts

@@ -362,4 +362,6 @@ export type {
   NavType,
 };
 
+export type { PerformanceMetricEvent } from './utils';
+
 export { __kbnBootstrap__ } from './kbn_bootstrap';

src/core/public/kbn_bootstrap.ts

@@ -9,12 +9,12 @@
 import { i18n } from '@kbn/i18n';
 import { CoreSystem } from './core_system';
 import { ApmSystem } from './apm_system';
-import { KBN_LOAD_MARKS } from './utils';
+import { KBN_LOAD_MARKS, LOAD_BOOTSTRAP_START } from './utils';
 
 /** @internal */
 export async function __kbnBootstrap__() {
   performance.mark(KBN_LOAD_MARKS, {
-    detail: 'bootstrap_started',
+    detail: LOAD_BOOTSTRAP_START,
   });
 
   const injectedMetadata = JSON.parse(