[ResponseOps] Visualize alerting metrics in Stack Monitoring

x-pack/plugins/alerting/server/rule_type_registry.test.ts

@@ -20,7 +20,6 @@ let mockedLicenseState: jest.Mocked<ILicenseState>;
 let ruleTypeRegistryParams: ConstructorOptions;
 
 const taskManager = taskManagerMock.createSetup();
-
 const inMemoryMetrics = inMemoryMetricsMock.create();
 
 beforeEach(() => {

x-pack/plugins/monitoring/public/application/pages/kibana/instance.tsx

@@ -37,6 +37,11 @@ import { RULE_KIBANA_VERSION_MISMATCH } from '../../../../common/constants';
 const KibanaInstance = ({ data, alerts }: { data: any; alerts: any }) => {
   const { zoomInfo, onBrush } = useCharts();
 
+  const showRules =
+    data.metrics.kibana_instance_rule_executions &&
+    data.metrics.kibana_instance_rule_executions.length &&
+    data.metrics.kibana_instance_rule_executions[0].indices_found.metricbeat;
+
   return (
     <EuiPage>
       <EuiPageBody>
@@ -95,6 +100,42 @@ const KibanaInstance = ({ data, alerts }: { data: any; alerts: any }) => {
               />
               <EuiSpacer />
             </EuiFlexItem>
+            {showRules && (
+              <>
+                <EuiFlexItem grow={true}>
+                  <MonitoringTimeseriesContainer
+                    series={data.metrics.kibana_instance_rule_executions}
+                    onBrush={onBrush}
+                    zoomInfo={zoomInfo}
+                  />
+                  <EuiSpacer />
+                </EuiFlexItem>
+                <EuiFlexItem grow={true}>
+                  <MonitoringTimeseriesContainer
+                    series={data.metrics.kibana_instance_rule_failures}
+                    onBrush={onBrush}
+                    zoomInfo={zoomInfo}
+                  />
+                  <EuiSpacer />
+                </EuiFlexItem>
+                <EuiFlexItem grow={true}>
+                  <MonitoringTimeseriesContainer
+                    series={data.metrics.kibana_instance_action_executions}
+                    onBrush={onBrush}
+                    zoomInfo={zoomInfo}
+                  />
+                  <EuiSpacer />
+                </EuiFlexItem>
+                <EuiFlexItem grow={true}>
+                  <MonitoringTimeseriesContainer
+                    series={data.metrics.kibana_instance_action_failures}
+                    onBrush={onBrush}
+                    zoomInfo={zoomInfo}
+                  />
+                  <EuiSpacer />
+                </EuiFlexItem>
+              </>
+            )}
           </EuiFlexGrid>
         </EuiPageContent>
       </EuiPageBody>

x-pack/plugins/monitoring/public/application/pages/kibana/overview.tsx

@@ -33,6 +33,11 @@ const KibanaOverview = ({ data }: { data: any }) => {
 
   if (!data) return null;
 
+  const showRules =
+    data.metrics.kibana_cluster_rule_overdue_count &&
+    data.metrics.kibana_cluster_rule_overdue_count.length &&
+    data.metrics.kibana_cluster_rule_overdue_count[0].indices_found.metricbeat;
+
   return (
     <EuiPage>
       <EuiPageBody>
@@ -57,6 +62,42 @@ const KibanaOverview = ({ data }: { data: any }) => {
               />
             </EuiFlexItem>
           </EuiFlexGroup>
+          {showRules && (
+            <>
+              <EuiFlexGroup>
+                <EuiFlexItem grow={true}>
+                  <MonitoringTimeseriesContainer
+                    series={data.metrics.kibana_cluster_rule_overdue_count}
+                    onBrush={onBrush}
+                    zoomInfo={zoomInfo}
+                  />
+                </EuiFlexItem>
+                <EuiFlexItem grow={true}>
+                  <MonitoringTimeseriesContainer
+                    series={data.metrics.kibana_cluster_rule_overdue_duration}
+                    onBrush={onBrush}
+                    zoomInfo={zoomInfo}
+                  />
+                </EuiFlexItem>
+              </EuiFlexGroup>
+              <EuiFlexGroup>
+                <EuiFlexItem grow={true}>
+                  <MonitoringTimeseriesContainer
+                    series={data.metrics.kibana_cluster_action_overdue_count}
+                    onBrush={onBrush}
+                    zoomInfo={zoomInfo}
+                  />
+                </EuiFlexItem>
+                <EuiFlexItem grow={true}>
+                  <MonitoringTimeseriesContainer
+                    series={data.metrics.kibana_cluster_action_overdue_duration}
+                    onBrush={onBrush}
+                    zoomInfo={zoomInfo}
+                  />
+                </EuiFlexItem>
+              </EuiFlexGroup>
+            </>
+          )}
         </EuiPageContent>
       </EuiPageBody>
     </EuiPage>

x-pack/plugins/monitoring/public/components/cluster/overview/kibana_panel.js

@@ -28,7 +28,7 @@ import { SetupModeFeature } from '../../../../common/enums';
 import { AlertsBadge } from '../../../alerts/badge';
 import { shouldShowAlertBadge } from '../../../alerts/lib/should_show_alert_badge';
 import { ExternalConfigContext } from '../../../application/contexts/external_config_context';
-import { formatNumber } from '../../../lib/format_number';
+import { formatNumber, formatPercentageUsage } from '../../../lib/format_number';
 import { getSafeForExternalLink } from '../../../lib/get_safe_for_external_link';
 import { isSetupModeFeatureEnabled } from '../../../lib/setup_mode';
 import { SetupModeContext } from '../../setup_mode/setup_mode_context';
@@ -143,6 +143,31 @@ export function KibanaPanel(props) {
                   values={{ maxTime: props.response_time_max }}
                 />
               </EuiDescriptionListDescription>
+              {props.rules.instance && props.rules.cluster && (
+                <>
+                  <EuiDescriptionListTitle className="eui-textBreakWord">
+                    <FormattedMessage
+                      id="xpack.monitoring.cluster.overview.kibanaPanel.ruleFailuresLabel"
+                      defaultMessage="Rule Success Ratio"
+                    />
+                  </EuiDescriptionListTitle>
+                  <EuiDescriptionListDescription data-test-subj="kbnRuleFailures">
+                    {formatPercentageUsage(
+                      props.rules.instance.executions - props.rules.instance.failures,
+                      props.rules.instance.executions
+                    )}
+                  </EuiDescriptionListDescription>
+                  <EuiDescriptionListTitle className="eui-textBreakWord">
+                    <FormattedMessage
+                      id="xpack.monitoring.cluster.overview.kibanaPanel.overdueTaskCountLabel"
+                      defaultMessage="Overdue Rules"
+                    />
+                  </EuiDescriptionListTitle>
+                  <EuiDescriptionListDescription data-test-subj="kbnOverdueRules">
+                    {props.rules.cluster.overdue.count}
+                  </EuiDescriptionListDescription>
+                </>
+              )}
             </EuiDescriptionList>
           </EuiPanel>
         </EuiFlexItem>

x-pack/plugins/monitoring/server/kibana_monitoring/bulk_uploader.ts

@@ -70,6 +70,7 @@ export class BulkUploader implements IBulkUploader {
   private _timer: NodeJS.Timer | null;
   private readonly _interval: number;
   private readonly config: MonitoringConfig;
+
   constructor({
     log,
     config,

x-pack/plugins/monitoring/server/lib/cluster/get_clusters_from_request.ts

@@ -6,7 +6,7 @@
  */
 
 import { notFound } from '@hapi/boom';
-import { get } from 'lodash';
+import { get, omit } from 'lodash';
 import { set } from '@elastic/safer-lodash-set';
 import { i18n } from '@kbn/i18n';
 import { getClustersStats } from './get_clusters_stats';
@@ -39,6 +39,7 @@ import { getLogTypes } from '../logs';
 import { isInCodePath } from './is_in_code_path';
 import { LegacyRequest, Cluster } from '../../types';
 import { RulesByType } from '../../../common/types/alerts';
+import { getClusterRuleDataForClusters, getInstanceRuleDataForClusters } from '../kibana/rules';
 
 /**
  * Get all clusters or the cluster associated with {@code clusterUuid} when it is defined.
@@ -168,17 +169,38 @@ export async function getClustersFromRequest(
     }
   }
   // add kibana data
-  const kibanas =
+  const [kibanas, kibanaClusterRules, kibanaInstanceRules] =
     isInCodePath(codePaths, [CODE_PATH_KIBANA]) && !isStandaloneCluster
-      ? await getKibanasForClusters(req, clusters, CCS_REMOTE_PATTERN)
-      : [];
+      ? await Promise.all([
+          getKibanasForClusters(req, clusters, CCS_REMOTE_PATTERN),
+          getClusterRuleDataForClusters(req, clusters, CCS_REMOTE_PATTERN),
+          getInstanceRuleDataForClusters(req, clusters, CCS_REMOTE_PATTERN),
+        ])
+      : [[], [], []];
   // add the kibana data to each cluster
   kibanas.forEach((kibana) => {
     const clusterIndex = clusters.findIndex(
       (cluster) =>
         get(cluster, 'elasticsearch.cluster.id', cluster.cluster_uuid) === kibana.clusterUuid
     );
     set(clusters[clusterIndex], 'kibana', kibana.stats);
+
+    const clusterKibanaRules = kibanaClusterRules.every((rule) => !Boolean(rule))
+      ? null
+      : kibanaClusterRules?.find((rule) => rule?.clusterUuid === kibana.clusterUuid);
+    const instanceKibanaRules = kibanaInstanceRules.every((rule) => !Boolean(rule))
+      ? null
+      : kibanaInstanceRules?.find((rule) => rule?.clusterUuid === kibana.clusterUuid);
+    set(
+      clusters[clusterIndex],
+      'kibana.rules.cluster',
+      clusterKibanaRules ? omit(clusterKibanaRules, 'clusterUuid') : null
+    );
+    set(
+      clusters[clusterIndex],
+      'kibana.rules.instance',
+      instanceKibanaRules ? omit(instanceKibanaRules, 'clusterUuid') : null
+    );
   });
 
   // add logstash data

x-pack/plugins/monitoring/server/lib/details/get_series.ts

@@ -18,13 +18,16 @@ import {
   CALCULATE_DURATION_UNTIL,
   INDEX_PATTERN_TYPES,
   STANDALONE_CLUSTER_CLUSTER_UUID,
+  METRICBEAT_INDEX_NAME_UNIQUE_TOKEN,
 } from '../../../common/constants';
 import { formatUTCTimestampForTimezone } from '../format_timezone';
 import { getNewIndexPatterns } from '../cluster/get_index_patterns';
 import { Globals } from '../../static_globals';
 import type { Metric } from '../metrics/metrics';
 
-type SeriesBucket = Bucket & { metric_mb_deriv?: { normalized_value: number } };
+type SeriesBucket = Bucket & { metric_mb_deriv?: { normalized_value: number } } & {
+  indices?: { buckets: Array<{ [key: string]: any }> };
+};
 
 /**
  * Derivative metrics for the first two agg buckets are unusable. For the first bucket, there
@@ -152,6 +155,11 @@ async function fetchSeries(
       },
       aggs: {
         ...dateHistogramSubAggs,
+        indices: {
+          terms: {
+            field: '_index',
+          },
+        },
       },
     },
   };
@@ -267,7 +275,7 @@ function handleSeries(
   timezone: string,
   response: ElasticsearchResponse
 ) {
-  const { derivative, calculation: customCalculation } = metric;
+  const { derivative, calculation: customCalculation, isNotSupportedInInternalCollection } = metric;
 
   function getAggregatedData(buckets: SeriesBucket[]) {
     const firstUsableBucketIndex = findFirstUsableBucketIndex(buckets, min);
@@ -277,28 +285,52 @@ function handleSeries(
       firstUsableBucketIndex,
       bucketSizeInSeconds * 1000
     );
+    let internalIndicesFound = false;
+    let mbIndicesFound = false;
     let data: Array<[string | number, number | null]> = [];
 
     if (firstUsableBucketIndex <= lastUsableBucketIndex) {
       // map buckets to values for charts
       const key = derivative ? 'metric_deriv.normalized_value' : 'metric.value';
       const calculation = customCalculation !== undefined ? customCalculation : defaultCalculation;
+      const usableBuckets = buckets.slice(firstUsableBucketIndex, lastUsableBucketIndex + 1); // take only the buckets we know are usable
+
+      data = usableBuckets.map((bucket) => {
+        // map buckets to X/Y coords for Flot charting
+        if (bucket.indices) {
+          for (const indexBucket of bucket.indices.buckets) {
+            if (indexBucket.key.includes(METRICBEAT_INDEX_NAME_UNIQUE_TOKEN)) {
+              mbIndicesFound = true;
+            } else {
+              internalIndicesFound = true;
+            }
+          }
+        }
 
-      data = buckets
-        .slice(firstUsableBucketIndex, lastUsableBucketIndex + 1) // take only the buckets we know are usable
-        .map((bucket) => [
+        return [
           formatUTCTimestampForTimezone(bucket.key, timezone),
           calculation(bucket, key, metric, bucketSizeInSeconds),
-        ]); // map buckets to X/Y coords for Flot charting
+        ];
+      });
     }
 
+    const indexSourceData = isNotSupportedInInternalCollection
+      ? {
+          indices_found: {
+            internal: internalIndicesFound,
+            metricbeat: mbIndicesFound,
+          },
+        }
+      : {};
+
     return {
       bucket_size: formatBucketSize(bucketSizeInSeconds),
       timeRange: {
         min: formatUTCTimestampForTimezone(min, timezone),
         max: formatUTCTimestampForTimezone(max, timezone),
       },
       metric: metric.serialize(),
+      ...indexSourceData,
       data,
     };
   }