[Monitoring] "Internal Monitoring" deprecation warning

x-pack/plugins/monitoring/public/lib/internal_monitoring_toasts.tsx

@@ -13,8 +13,8 @@ import { toMountPoint } from '../../../../../src/plugins/kibana_react/public';
 import { isInSetupMode, toggleSetupMode } from './setup_mode';
 
 export interface MonitoringIndicesTypes {
-  legacyIndices: boolean;
-  metricbeatIndices: boolean;
+  legacyIndices: number;
+  metricbeatIndices: number;
 }
 
 const enterSetupModeLabel = () =>
@@ -40,7 +40,7 @@ const showIfLegacyOnlyIndices = () => {
       <div>
         <p>
           {i18n.translate('xpack.monitoring.internalMonitoringToast.description', {
-            defaultMessage: `It appears you are using "Internal Collection" for Stack Monitoring. 
+            defaultMessage: `It appears you are using "Legacy Collection" for Stack Monitoring. 
             This method of monitoring will no longer be supported in the next major release (8.0.0). 
             Please follow the steps in setup mode to start monitoring with Metricbeat.`,
           })}
@@ -73,14 +73,14 @@ const showIfLegacyAndMetricbeatIndices = () => {
     title: toMountPoint(
       <FormattedMessage
         id="xpack.monitoring.internalAndMetricbeatMonitoringToast.title"
-        defaultMessage="Partial Internal Monitoring Detected"
+        defaultMessage="Partial Legacy Monitoring Detected"
       />
     ),
     text: toMountPoint(
       <div>
         <p>
           {i18n.translate('xpack.monitoring.internalAndMetricbeatMonitoringToast.description', {
-            defaultMessage: `It appears you are using both Metricbeat and "Internal Collection" for Stack Monitoring. 
+            defaultMessage: `It appears you are using both Metricbeat and "Legacy Collection" for Stack Monitoring. 
             only Metricbeat type monitoring will be supported in the next major release (8.0.0). 
             Please follow the steps in setup mode to migrate the rest of the monitoring to Metricbeat.`,
           })}

x-pack/plugins/monitoring/server/routes/api/v1/elasticsearch_settings/check/internal_monitoring.ts

@@ -4,46 +4,97 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
-import { CatIndicesParams } from 'elasticsearch';
+// @ts-ignore
+import { RequestHandlerContext } from 'kibana/server';
+import { getIndexPatterns } from '../../../../../lib/cluster/get_index_patterns';
+
 // @ts-ignore
 import { handleError } from '../../../../../lib/errors';
 import { RouteDependencies } from '../../../../../types';
 
-export function internalMonitoringCheckRoute(_server: unknown, npRoute: RouteDependencies) {
+const queryBody = {
+  size: 15,
+  query: {
+    bool: {
+      filter: [
+        {
+          range: {
+            timestamp: {
+              gte: 'now-15m',
+              lte: 'now',
+            },
+          },
+        },
+      ],
+    },
+  },
+  sort: [
+    {
+      timestamp: {
+        order: 'desc',
+      },
+    },
+  ],
+  _source: {
+    excludes: ['*'],
+  },
+};
+
+const checkLatestMonitoringIsLegacy = async (context: RequestHandlerContext, index: string) => {
+  const { client: esClient } = context.core.elasticsearch.legacy;
+  const result = await esClient.callAsCurrentUser('search', {
+    index,
+    body: queryBody,
+  });
+
+  const {
+    hits: { hits },
+  } = result;
+  const counts = {
+    legacyIndicesCount: 0,
+    mbIndicesCount: 0,
+  };
+
+  if (!hits?.length) {
+    return counts;
+  }
+
+  counts.mbIndicesCount = hits.filter(({ _index }: { _index: string }) =>
+    _index.includes('-mb-')
+  ).length;
+
+  counts.legacyIndicesCount = hits.length - counts.mbIndicesCount;
+
+  return counts;
+};
+
+export function internalMonitoringCheckRoute(server: unknown, npRoute: RouteDependencies) {
   npRoute.router.get(
     {
       path: '/api/monitoring/v1/elasticsearch_settings/check/internal_monitoring',
-      options: { tags: ['access:monitoring'] },
       validate: false,
     },
     async (context, _request, response) => {
       try {
-        const catQuery: Pick<CatIndicesParams, 'format' | 'h'> & {
-          expand_wildcards: string;
-          index?: string;
-        } = {
-          format: 'json',
-          h: 'index',
-          expand_wildcards: 'hidden,all',
-          index: '.monitoring-*',
+        const typeCount = {
+          legacy_indices: 0,
+          mb_indices: 0,
         };
 
-        const { client: esClient } = context.core.elasticsearch.legacy;
-        const monitoringIndices = await esClient.callAsInternalUser('transport.request', {
-          method: 'GET',
-          path: '/_cat/indices',
-          query: catQuery,
-        });
+        const { esIndexPattern, kbnIndexPattern, lsIndexPattern } = getIndexPatterns(server);
+        const indexCounts = await Promise.all([
+          checkLatestMonitoringIsLegacy(context, esIndexPattern),
+          checkLatestMonitoringIsLegacy(context, kbnIndexPattern),
+          checkLatestMonitoringIsLegacy(context, lsIndexPattern),
+        ]);
 
-        const mbIndices = monitoringIndices.filter(({ index }: { index: string }) =>
-          index.includes('-mb-')
-        );
+        indexCounts.forEach((counts) => {
+          typeCount.legacy_indices += counts.legacyIndicesCount;
+          typeCount.mb_indices += counts.mbIndicesCount;
+        });
 
         return response.ok({
-          body: {
-            legacy_indices: Boolean(monitoringIndices.length - mbIndices.length),
-            mb_indices: Boolean(mbIndices.length),
-          },
+          body: typeCount,
         });
       } catch (err) {
         throw handleError(err);