Add score details, add tests

Author: jotak

web/src/components/health/__tests__/helper.spec.tsx

@@ -0,0 +1,76 @@
+import { AlertStates } from '@openshift-console/dynamic-plugin-sdk';
+import { AlertWithRuleName, ByResource, computeAlertScore, computeScore } from '../helper';
+
+const mockAlert = (
+  name: string,
+  severity: string,
+  state: string,
+  threshold: number,
+  value: number
+): AlertWithRuleName => {
+  return {
+    ruleName: name,
+    labels: { alertname: name, severity: severity },
+    state: state as AlertStates,
+    annotations: {},
+    ruleID: '',
+    metadata: { thresholdF: threshold, threshold: '', unit: '%' },
+    value: value
+  };
+};
+
+describe('health helpers', () => {
+  it('should compute unweighted alert min score', () => {
+    const alert = mockAlert('test', 'critical', 'firing', 10, 10);
+    const score = computeAlertScore(alert);
+    expect(score.rawScore).toBeCloseTo(9.47, 2);
+    expect(score.weight).toEqual(1);
+  });
+
+  it('should compute unweighted alert max score', () => {
+    const alert = mockAlert('test', 'critical', 'firing', 10, 100);
+    const score = computeAlertScore(alert);
+    expect(score.rawScore).toEqual(0);
+    expect(score.weight).toEqual(1);
+  });
+
+  it('should compute weighted alert score', () => {
+    const alert = mockAlert('test', 'info', 'pending', 10, 10);
+    const score = computeAlertScore(alert);
+    expect(score.rawScore).toBeCloseTo(9.47, 2);
+    expect(score.weight).toEqual(0.12);
+  });
+
+  it('should compute full score', () => {
+    // Start with an empty one => max score
+    const r: ByResource = {
+      name: 'test',
+      critical: { firing: [], pending: [], silenced: [], inactive: [] },
+      warning: { firing: [], pending: [], silenced: [], inactive: [] },
+      other: { firing: [], pending: [], silenced: [], inactive: [] },
+      score: { total: 0, details: [] }
+    };
+    expect(computeScore(r).total).toEqual(10);
+
+    // Add 3 inactive alerts => still max score
+    r.critical.inactive.push('test-critical');
+    r.warning.inactive.push('test-warning');
+    r.other.inactive.push('test-info');
+    expect(computeScore(r).total).toEqual(10);
+
+    // Turn the inactive info into pending => slightly decreasing score
+    r.other.inactive = [];
+    r.other.pending = [mockAlert('test-info', 'info', 'pending', 10, 20)];
+    expect(computeScore(r).total).toBeCloseTo(9.9, 1);
+
+    // Turn the inactive warning into firing => more decreasing score
+    r.warning.inactive = [];
+    r.warning.firing = [mockAlert('test-warning', 'warning', 'firing', 10, 40)];
+    expect(computeScore(r).total).toBeCloseTo(8.5, 1);
+
+    // Turn the inactive critical into firing => more decrease
+    r.critical.inactive = [];
+    r.critical.firing = [mockAlert('test-critical', 'critical', 'firing', 10, 40)];
+    expect(computeScore(r).total).toBeCloseTo(6.5, 1);
+  });
+});

web/src/components/health/health-card.tsx

@@ -96,7 +96,7 @@ export const HealthCard: React.FC<HealthCardProps> = ({ stats, kind, isDark, isS
           </FlexItem>
           <FlexItem>
             <TextContent>
-              <Text component={TextVariants.h1}>{valueFormat(stats.score)}</Text>
+              <Text component={TextVariants.h1}>{valueFormat(stats.score.total)}</Text>
             </TextContent>
           </FlexItem>
         </Flex>

web/src/components/health/health-heatmap.tsx

@@ -5,7 +5,7 @@ import * as React from 'react';
 import { useTranslation } from 'react-i18next';
 import { valueFormat } from '../../utils/format';
 import { AlertDetails, AlertDetailsValue } from './alert-details';
-import { AlertWithRuleName, ByResource, computeAlertScore, getAllAlerts } from './helper';
+import { AlertWithRuleName, ByResource, computeExcessRatioStatusWeighted, getAllAlerts } from './helper';
 
 import './heatmap.css';
 
@@ -132,7 +132,7 @@ export const HealthHeatmap: React.FC<HealthHeatmapProps> = ({ info, interactive
           : a.labels.severity === 'warning'
           ? warningColorMap
           : infoColorMap;
-      const score = computeAlertScore(a, true);
+      const score = computeExcessRatioStatusWeighted(a);
       return {
         score,
         colorMap: colorMap,

web/src/components/health/helper.ts

@@ -13,7 +13,7 @@ export type ByResource = {
   critical: SeverityStats;
   warning: SeverityStats;
   other: SeverityStats;
-  score: number;
+  score: Score;
 };
 
 type SeverityStats = {
@@ -41,6 +41,17 @@ type HealthMetadata = {
   namespaceLabels?: string[];
 };
 
+type Score = {
+  total: number;
+  details: ScoreDetail[];
+};
+
+type ScoreDetail = {
+  alertName: string;
+  rawScore: number;
+  weight: number;
+};
+
 export const getHealthMetadata = (annotations: PrometheusLabels): HealthMetadata | undefined => {
   if ('netobserv_io_network_health' in annotations) {
     const md = (JSON.parse(annotations['netobserv_io_network_health']) as HealthMetadata) || undefined;
@@ -141,7 +152,7 @@ const statsFromGrouped = (name: string, grouped: AlertWithRuleName[]): ByResourc
     critical: { firing: [], pending: [], silenced: [], inactive: [] },
     warning: { firing: [], pending: [], silenced: [], inactive: [] },
     other: { firing: [], pending: [], silenced: [], inactive: [] },
-    score: 0
+    score: { total: 0, details: [] }
   };
   _.uniqWith(grouped, (a, b) => {
     return a.ruleName === b.ruleName && _.isEqual(a.labels, b.labels);
@@ -241,37 +252,52 @@ const getSeverityWeight = (a: AlertWithRuleName) => {
   }
 };
 
+const getStateWeight = (a: AlertWithRuleName) => {
+  switch (a.state) {
+    case 'pending':
+      return pendingWeight;
+    case 'silenced':
+      return silencedWeight;
+  }
+  return 1;
+};
+
 // Score [0,10]; higher is better
-export const computeScore = (r: ByResource): number => {
+export const computeScore = (r: ByResource): Score => {
   const allAlerts = getAllAlerts(r);
-  const score = allAlerts.map(a => computeAlertScore(a)).reduce((a, b) => a + b, 0);
-  if (score === 0) {
-    return 10;
+  const allScores = allAlerts
+    .map(computeAlertScore)
+    .concat(r.critical.inactive.map(name => ({ alertName: name, rawScore: 10, weight: criticalWeight })))
+    .concat(r.warning.inactive.map(name => ({ alertName: name, rawScore: 10, weight: warningWeight })))
+    .concat(r.other.inactive.map(name => ({ alertName: name, rawScore: 10, weight: minorWeight })));
+  const sum = allScores.map(s => s.rawScore * s.weight).reduce((a, b) => a + b, 0);
+  const sumWeights = allScores.map(s => s.weight).reduce((a, b) => a + b, 0);
+  if (sumWeights === 0) {
+    return { total: 10, details: [] };
   }
-  const div =
-    allAlerts.map(getSeverityWeight).reduce((a, b) => a + b, 0) +
-    r.critical.inactive.length * criticalWeight +
-    r.warning.inactive.length * warningWeight +
-    r.other.inactive.length * minorWeight;
-  return 10 * (1 - score / div);
+  return { total: sum / sumWeights, details: allScores };
 };
 
 // Score [0,1]; lower is better
-export const computeAlertScore = (a: AlertWithRuleName, ignoreSeverity?: boolean): number => {
-  let multiplier = ignoreSeverity ? 1 : getSeverityWeight(a);
-  switch (a.state) {
-    case 'pending':
-      multiplier *= pendingWeight;
-      break;
-    case 'silenced':
-      multiplier *= silencedWeight;
-      break;
-  }
+const computeExcessRatio = (a: AlertWithRuleName): number => {
   // Assuming the alert value is a [0-100] percentage. Needs update if more use cases come up.
   const threshold = (a.metadata?.thresholdF || 0) / 2;
   const range = 100 - threshold;
   const excess = Math.max((a.value as number) - threshold, 0);
-  return (excess * multiplier) / range;
+  return excess / range;
+};
+
+export const computeExcessRatioStatusWeighted = (a: AlertWithRuleName): number => {
+  return computeExcessRatio(a) * getStateWeight(a);
+};
+
+// Score [0,10]; higher is better
+export const computeAlertScore = (a: AlertWithRuleName): ScoreDetail => {
+  return {
+    alertName: a.ruleName,
+    rawScore: 10 * (1 - computeExcessRatio(a)),
+    weight: getSeverityWeight(a) * getStateWeight(a)
+  };
 };
 
 export const isSilenced = (silence: SilenceMatcher[], labels: PrometheusLabels): boolean => {