Merge branch '7.x' into backport/7.x/pr-65598

.eslintrc.js

@@ -118,7 +118,6 @@ module.exports = {
       files: ['x-pack/plugins/lens/**/*.{js,ts,tsx}'],
       rules: {
         'react-hooks/exhaustive-deps': 'off',
-        'react-hooks/rules-of-hooks': 'off',
       },
     },
     {

.i18nrc.json

@@ -34,7 +34,7 @@
     "kibana_utils": "src/plugins/kibana_utils",
     "navigation": "src/plugins/navigation",
     "newsfeed": "src/plugins/newsfeed",
-    "regionMap": "src/legacy/core_plugins/region_map",
+    "regionMap": "src/plugins/region_map",
     "savedObjects": "src/plugins/saved_objects",
     "savedObjectsManagement": "src/plugins/saved_objects_management",
     "server": "src/legacy/server",

packages/kbn-dev-utils/src/ci_stats_reporter/README.md

@@ -8,7 +8,7 @@ This class integrates with the `ciStats.trackBuild {}` Jenkins Pipeline function
 
 To create an instance of the reporter, import the class and call `CiStatsReporter.fromEnv(log)` (passing it a tooling log).
 
-#### `CiStatsReporter#metric(name: string, subName: string, value: number)`
+#### `CiStatsReporter#metrics(metrics: Array<{ group: string, id: string, value: number }>)`
 
 Use this method to record metrics in the Kibana CI Stats service.
 
@@ -19,5 +19,11 @@ import { CiStatsReporter, ToolingLog } from '@kbn/dev-utils';
 
 const log = new ToolingLog(...);
 const reporter = CiStatsReporter.fromEnv(log)
-reporter.metric('Build speed', specificBuildName, timeToRunBuild)
+reporter.metrics([
+  {
+    group: 'Build size',
+    id: specificBuildName,
+    value: sizeOfBuild
+  }
+])
 ```

packages/kbn-dev-utils/src/ci_stats_reporter/ci_stats_reporter.ts

@@ -84,32 +84,31 @@ export class CiStatsReporter {
     return !!this.config;
   }
 
-  async metric(name: string, subName: string, value: number) {
+  async metrics(metrics: Array<{ group: string; id: string; value: number }>) {
     if (!this.config) {
       return;
     }
 
     let attempt = 0;
     const maxAttempts = 5;
+    const bodySummary = metrics
+      .map(({ group, id, value }) => `[${group}/${id}=${value}]`)
+      .join(' ');
 
     while (true) {
       attempt += 1;
 
       try {
         await Axios.request({
           method: 'POST',
-          url: '/metric',
+          url: '/v1/metrics',
           baseURL: this.config.apiUrl,
-          params: {
-            buildId: this.config.buildId,
-          },
           headers: {
             Authorization: `token ${this.config.apiToken}`,
           },
           data: {
-            name,
-            subName,
-            value,
+            buildId: this.config.buildId,
+            metrics,
           },
         });
 
@@ -125,14 +124,14 @@ export class CiStatsReporter {
           this.log.warning(
             `error recording metric [status=${error.response.status}] [resp=${inspect(
               error.response.data
-            )}] [${name}/${subName}=${value}]`
+            )}] ${bodySummary}`
           );
           return;
         }
 
         if (attempt === maxAttempts) {
           this.log.warning(
-            `failed to reach kibana-ci-stats service too many times, unable to record metric [${name}/${subName}=${value}]`
+            `failed to reach kibana-ci-stats service too many times, unable to record metric ${bodySummary}`
           );
           return;
         }

packages/kbn-optimizer/src/cli.ts

@@ -21,7 +21,7 @@ import 'source-map-support/register';
 
 import Path from 'path';
 
-import { run, REPO_ROOT, createFlagError, createFailError, CiStatsReporter } from '@kbn/dev-utils';
+import { run, REPO_ROOT, createFlagError, CiStatsReporter } from '@kbn/dev-utils';
 
 import { logOptimizerState } from './log_optimizer_state';
 import { OptimizerConfig } from './optimizer';
@@ -82,9 +82,9 @@ run(
       throw createFlagError('expected --scan-dir to be a string');
     }
 
-    const reportStatsName = flags['report-stats'];
-    if (reportStatsName !== undefined && typeof reportStatsName !== 'string') {
-      throw createFlagError('expected --report-stats to be a string');
+    const reportStats = flags['report-stats'] ?? false;
+    if (typeof reportStats !== 'boolean') {
+      throw createFlagError('expected --report-stats to have no value');
     }
 
     const config = OptimizerConfig.create({
@@ -103,22 +103,32 @@ run(
 
     let update$ = runOptimizer(config);
 
-    if (reportStatsName) {
+    if (reportStats) {
       const reporter = CiStatsReporter.fromEnv(log);
 
       if (!reporter.isEnabled()) {
-        throw createFailError('Unable to initialize CiStatsReporter from env');
+        log.warning('Unable to initialize CiStatsReporter from env');
       }
 
-      update$ = update$.pipe(reportOptimizerStats(reporter, reportStatsName));
+      update$ = update$.pipe(reportOptimizerStats(reporter, config));
     }
 
     await update$.pipe(logOptimizerState(log, config)).toPromise();
   },
   {
     flags: {
-      boolean: ['core', 'watch', 'oss', 'examples', 'dist', 'cache', 'profile', 'inspect-workers'],
-      string: ['workers', 'scan-dir', 'report-stats'],
+      boolean: [
+        'core',
+        'watch',
+        'oss',
+        'examples',
+        'dist',
+        'cache',
+        'profile',
+        'inspect-workers',
+        'report-stats',
+      ],
+      string: ['workers', 'scan-dir'],
       default: {
         core: true,
         examples: true,
@@ -136,7 +146,7 @@ run(
         --dist             create bundles that are suitable for inclusion in the Kibana distributable
         --scan-dir         add a directory to the list of directories scanned for plugins (specify as many times as necessary)
         --no-inspect-workers  when inspecting the parent process, don't inspect the workers
-        --report-stats=[name] attempt to report stats about this execution of the build to the kibana-ci-stats service using this name
+        --report-stats     attempt to report stats about this execution of the build to the kibana-ci-stats service using this name
       `,
     },
   }

packages/kbn-optimizer/src/report_optimizer_stats.ts

@@ -21,10 +21,10 @@ import { materialize, mergeMap, dematerialize } from 'rxjs/operators';
 import { CiStatsReporter } from '@kbn/dev-utils';
 
 import { OptimizerUpdate$ } from './run_optimizer';
-import { OptimizerState } from './optimizer';
+import { OptimizerState, OptimizerConfig } from './optimizer';
 import { pipeClosure } from './common';
 
-export function reportOptimizerStats(reporter: CiStatsReporter, name: string) {
+export function reportOptimizerStats(reporter: CiStatsReporter, config: OptimizerConfig) {
   return pipeClosure((update$: OptimizerUpdate$) => {
     let lastState: OptimizerState | undefined;
     return update$.pipe(
@@ -35,7 +35,18 @@ export function reportOptimizerStats(reporter: CiStatsReporter, name: string) {
         }
 
         if (n.kind === 'C' && lastState) {
-          await reporter.metric('@kbn/optimizer build time', name, lastState.durSec);
+          await reporter.metrics(
+            config.bundles.map(bundle => {
+              // make the cache read from the cache file since it was likely updated by the worker
+              bundle.cache.refresh();
+
+              return {
+                group: `@kbn/optimizer bundle module count`,
+                id: bundle.id,
+                value: bundle.cache.getModuleCount() || 0,
+              };
+            })
+          );
         }
 
         return n;

packages/kbn-pm/dist/index.js

@@ -43940,30 +43940,29 @@ class CiStatsReporter {
     isEnabled() {
         return !!this.config;
     }
-    async metric(name, subName, value) {
+    async metrics(metrics) {
         var _a, _b, _c, _d;
         if (!this.config) {
             return;
         }
         let attempt = 0;
         const maxAttempts = 5;
+        const bodySummary = metrics
+            .map(({ group, id, value }) => `[${group}/${id}=${value}]`)
+            .join(' ');
         while (true) {
             attempt += 1;
             try {
                 await axios_1.default.request({
                     method: 'POST',
-                    url: '/metric',
+                    url: '/v1/metrics',
                     baseURL: this.config.apiUrl,
-                    params: {
-                        buildId: this.config.buildId,
-                    },
                     headers: {
                         Authorization: `token ${this.config.apiToken}`,
                     },
                     data: {
-                        name,
-                        subName,
-                        value,
+                        buildId: this.config.buildId,
+                        metrics,
                     },
                 });
                 return;
@@ -43975,11 +43974,11 @@ class CiStatsReporter {
                 }
                 if (((_b = error) === null || _b === void 0 ? void 0 : _b.response) && error.response.status !== 502) {
                     // error response from service was received so warn the user and move on
-                    this.log.warning(`error recording metric [status=${error.response.status}] [resp=${util_1.inspect(error.response.data)}] [${name}/${subName}=${value}]`);
+                    this.log.warning(`error recording metric [status=${error.response.status}] [resp=${util_1.inspect(error.response.data)}] ${bodySummary}`);
                     return;
                 }
                 if (attempt === maxAttempts) {
-                    this.log.warning(`failed to reach kibana-ci-stats service too many times, unable to record metric [${name}/${subName}=${value}]`);
+                    this.log.warning(`failed to reach kibana-ci-stats service too many times, unable to record metric ${bodySummary}`);
                     return;
                 }
                 // we failed to reach the backend and we have remaining attempts, lets retry after a short delay

src/dev/build/tasks/build_kibana_platform_plugins.js

@@ -39,11 +39,10 @@ export const BuildKibanaPlatformPluginsTask = {
     });
 
     const reporter = CiStatsReporter.fromEnv(log);
-    const reportStatsName = build.isOss() ? 'oss distributable' : 'default distributable';
 
     await runOptimizer(optimizerConfig)
       .pipe(
-        reportOptimizerStats(reporter, reportStatsName),
+        reportOptimizerStats(reporter, optimizerConfig),
         logOptimizerState(log, optimizerConfig)
       )
       .toPromise();

src/dev/build/tasks/create_archives_task.js

@@ -17,24 +17,38 @@
  * under the License.
  */
 
-import path from 'path';
+import Path from 'path';
+import Fs from 'fs';
+import { promisify } from 'util';
+
+import { CiStatsReporter } from '@kbn/dev-utils';
+
 import { mkdirp, compress } from '../lib';
 
+const asyncStat = promisify(Fs.stat);
+
 export const CreateArchivesTask = {
   description: 'Creating the archives for each platform',
 
   async run(config, log, build) {
+    const archives = [];
+
     // archive one at a time, parallel causes OOM sometimes
     for (const platform of config.getTargetPlatforms()) {
       const source = build.resolvePathForPlatform(platform, '.');
       const destination = build.getPlatformArchivePath(platform);
 
       log.info('archiving', source, 'to', destination);
 
-      await mkdirp(path.dirname(destination));
+      await mkdirp(Path.dirname(destination));
 
-      switch (path.extname(destination)) {
+      switch (Path.extname(destination)) {
         case '.zip':
+          archives.push({
+            format: 'zip',
+            path: destination,
+          });
+
           await compress(
             'zip',
             {
@@ -51,6 +65,11 @@ export const CreateArchivesTask = {
           break;
 
         case '.gz':
+          archives.push({
+            format: 'tar',
+            path: destination,
+          });
+
           await compress(
             'tar',
             {
@@ -71,5 +90,20 @@ export const CreateArchivesTask = {
           throw new Error(`Unexpected extension for archive destination: ${destination}`);
       }
     }
+
+    const reporter = CiStatsReporter.fromEnv(log);
+    if (reporter.isEnabled()) {
+      await reporter.metrics(
+        await Promise.all(
+          archives.map(async ({ format, path }) => {
+            return {
+              group: `${build.isOss() ? 'oss ' : ''}distributable size`,
+              id: format,
+              value: (await asyncStat(path)).size,
+            };
+          })
+        )
+      );
+    }
   },
 };