Merge pull request #504 from newrelic/update-workloads-status

feat: refactor workload status calculation and display of incidents

Author: amit-y

src/components/signal-detail-sidebar/incidents.js

@@ -7,23 +7,32 @@ import {
   durationStringForViolation,
   formatTimestamp,
   generateIncidentsList,
+  isWorkload,
 } from '../../utils';
 import { SIGNAL_TYPES, UI_CONTENT } from '../../constants';
 
 const Incidents = ({ type, data, timeWindow }) => {
   const [bannerMessage, setBannerMessage] = useState('');
   const [incidentsList, setIncidentsList] = useState([]);
   const [maxIncidentsShown, setMaxIncidentsShown] = useState(1);
+  const [shouldShowAllIncidents, setShouldShowAllIncidents] = useState(false);
 
   useEffect(() => {
     if (!data) return;
 
     const incids = generateIncidentsList({ type, data, timeWindow });
+    const showAll = type === SIGNAL_TYPES.ALERT || isWorkload(data);
+    let bnrMsg = '';
+    if (isWorkload(data)) {
+      bnrMsg = UI_CONTENT.SIGNAL.DETAILS.WORKLOAD_RULES_DISCLAIMER;
+    }
+    if (!incids.length) {
+      bnrMsg = UI_CONTENT.SIGNAL.DETAILS.NO_RECENT_INCIDENTS;
+    }
 
-    setBannerMessage(
-      incids.length ? '' : UI_CONTENT.SIGNAL.DETAILS.NO_RECENT_INCIDENTS
-    );
-    setMaxIncidentsShown(type === SIGNAL_TYPES.ALERT ? incids.length || 0 : 1);
+    setBannerMessage(bnrMsg);
+    setShouldShowAllIncidents(showAll);
+    setMaxIncidentsShown(() => (showAll ? incids.length || 0 : 1));
     setIncidentsList(incids);
   }, [type, data, timeWindow]);
 
@@ -96,7 +105,7 @@ const Incidents = ({ type, data, timeWindow }) => {
           []
         )}
       </div>
-      {type === SIGNAL_TYPES.ENTITY && incidentsList?.length > 1 ? (
+      {type === !shouldShowAllIncidents && incidentsList?.length > 1 ? (
         <div className="incidents-footer">
           <Button
             variant={Button.VARIANT.SECONDARY}

src/components/signal-detail-sidebar/index.js

@@ -1,4 +1,4 @@
-import React, { useContext, useEffect, useState } from 'react';
+import React, { useContext, useEffect, useRef, useState } from 'react';
 import PropTypes from 'prop-types';
 
 import {
@@ -7,18 +7,20 @@ import {
   HeadingText,
   InlineMessage,
   Link,
+  NerdGraphQuery,
   SectionMessage,
   navigation,
 } from 'nr1';
 
-import { SIGNAL_TYPES } from '../../constants';
+import { SIGNAL_TYPES, STATUSES } from '../../constants';
 
 import Incidents from './incidents';
 import GoldenMetrics from './golden-metrics';
 import { AppContext } from '../../contexts';
 
 import typesList from '../../../nerdlets/signal-selection/types.json';
-import { formatTimestamp } from '../../utils';
+import { formatTimestamp, isWorkload } from '../../utils';
+import { statusesFromGuidsArray, workloadEntitiesQuery } from '../../queries';
 
 const NO_ENTITY_TYPE = '(unknown entity type)';
 
@@ -36,6 +38,8 @@ const SignalDetailSidebar = ({ guid, name, type, data, timeWindow }) => {
   const [hasAccessToEntity, setHasAccessToEntity] = useState(false);
   const [signalAccount, setSignalAccount] = useState();
   const [detailLinkText, setDetailLinkText] = useState('View entity details');
+  const [incidentsData, setIncidentsData] = useState(null);
+  const prevTimeWindow = useRef({});
 
   useEffect(() => {
     const [acctId, condId] = ((atob(guid) || '').split('|') || []).reduce(
@@ -59,6 +63,94 @@ const SignalDetailSidebar = ({ guid, name, type, data, timeWindow }) => {
     }
   }, [guid, type, account, accounts]);
 
+  useEffect(() => {
+    if (
+      type !== SIGNAL_TYPES.ENTITY ||
+      !isWorkload(data) ||
+      !(
+        data.statusValueCode === 3 ||
+        data.statusValueCode === 2 ||
+        data.alertSeverity === STATUSES.CRITICAL ||
+        data.alertSeverity === STATUSES.WARNING
+      )
+    ) {
+      setIncidentsData(data);
+      return;
+    }
+
+    let shouldClearData = false;
+    const { start: prevStart, end: prevEnd } = prevTimeWindow.current || {};
+    if (timeWindow.start !== prevStart || timeWindow.end !== prevEnd) {
+      shouldClearData = true;
+      prevTimeWindow.current = timeWindow;
+    }
+
+    const loadWorkloadIncidents = async (g) => {
+      const {
+        data: {
+          actor: {
+            entity: { relatedEntities: { results = [] } = {} } = {},
+          } = {},
+        } = {},
+        error,
+      } = await NerdGraphQuery.query({
+        query: workloadEntitiesQuery,
+        variables: { guid: g },
+      });
+      if (error) {
+        console.error('Error listing workload entities', error);
+        return;
+      }
+      const workloadEntitiesGuids = results?.reduce(
+        (acc, { target: { guid: g } = {} }) => (g ? [...acc, g] : acc),
+        []
+      );
+      const {
+        data: { actor: { __typename, ...entitiesObj } = {} } = {}, // eslint-disable-line no-unused-vars
+        error: error2,
+      } = await NerdGraphQuery.query({
+        query: statusesFromGuidsArray([workloadEntitiesGuids], timeWindow),
+      });
+      if (error2) {
+        console.error('Error loading workload entities', error2);
+        return;
+      }
+      const violationsKey =
+        timeWindow?.start && timeWindow?.end
+          ? 'alertViolations'
+          : 'recentAlertViolations';
+      Object.keys(entitiesObj).forEach((entitiesKey) => {
+        entitiesObj[entitiesKey]?.forEach((entity) => {
+          if (isWorkload(entity)) {
+            loadWorkloadIncidents(entity.guid);
+            return;
+          }
+          const violations = entity?.[violationsKey] || [];
+          if (violations.length) {
+            setIncidentsData((d) =>
+              d && !shouldClearData
+                ? {
+                    ...d,
+                    [violationsKey]: [
+                      ...(d[violationsKey] || []),
+                      ...violations,
+                    ],
+                  }
+                : {
+                    ...data,
+                    [violationsKey]: [
+                      ...(data[violationsKey] || []),
+                      ...violations,
+                    ],
+                  }
+            );
+          }
+        });
+      });
+    };
+    loadWorkloadIncidents(guid);
+  }, [guid, type, data, timeWindow]);
+
   return (
     <div className="signal-detail-sidebar">
       <div className="signal-header">
@@ -98,7 +190,7 @@ const SignalDetailSidebar = ({ guid, name, type, data, timeWindow }) => {
       </div>
       {hasAccessToEntity ? (
         <>
-          <Incidents type={type} data={data} timeWindow={timeWindow} />
+          <Incidents type={type} data={incidentsData} timeWindow={timeWindow} />
           {type === SIGNAL_TYPES.ENTITY ? (
             <GoldenMetrics guid={guid} data={data} timeWindow={timeWindow} />
           ) : null}

src/components/stages/index.js

@@ -37,6 +37,7 @@ import {
   incidentsSearchQuery,
   issuesForConditionsQuery,
   statusesFromGuidsArray,
+  workloadsStatusesQuery,
 } from '../../queries';
 import {
   addSignalStatuses,
@@ -45,8 +46,11 @@ import {
   batchAlertConditionsByAccount,
   batchedIncidentIdsFromIssuesQuery,
   entitiesDetailsFromQueryResults,
+  fifteenMinutesAgo,
+  getWorstWorkloadStatusValue,
   guidsToArray,
   incidentsFromIncidentsBlocks,
+  isWorkload,
   signalDetailsObject,
   statusFromStatuses,
   threeDaysAgo,
@@ -61,7 +65,6 @@ import {
   UI_CONTENT,
   ALERT_STATUSES,
   MAX_PARAMS_IN_QUERY,
-  WORKLOAD_TYPE,
 } from '../../constants';
 import { useDebugLogger } from '../../hooks';
 
@@ -121,11 +124,11 @@ const Stages = forwardRef(
       async (entitiesGuids, timeWindow, isForCache) => {
         setIsLoading?.(true);
         clearTimeout(entitiesStatusTimeoutId.current);
-        const entitesGuidsArray = guidsToArray(
+        const entitiesGuidsArray = guidsToArray(
           { entitiesGuids },
           MAX_PARAMS_IN_QUERY
         );
-        const query = statusesFromGuidsArray(entitesGuidsArray, timeWindow);
+        const query = statusesFromGuidsArray(entitiesGuidsArray, timeWindow);
         debugString(query, 'Entities query');
         const { data: { actor = {} } = {}, error } = await NerdGraphQuery.query(
           {
@@ -144,66 +147,6 @@ const Stages = forwardRef(
           return;
         }
         const entitiesStatusesObj = entitiesDetailsFromQueryResults(actor);
-        const { workloads, workloadEntities } = Object.keys(
-          entitiesStatusesObj
-        ).reduce(
-          (acc, cur) => {
-            const { type: t, relatedEntities } = entitiesStatusesObj[cur];
-            if (t === WORKLOAD_TYPE && relatedEntities?.results?.length) {
-              const { workloadEntitiesGuids, guidsWOStatus } =
-                relatedEntities.results.reduce(
-                  ({ workloadEntitiesGuids, guidsWOStatus }, re) => {
-                    const g = re?.target?.entity?.guid;
-                    if (!g) return { workloadEntitiesGuids, guidsWOStatus };
-                    return {
-                      workloadEntitiesGuids: [...workloadEntitiesGuids, g],
-                      guidsWOStatus:
-                        g in entitiesStatusesObj || guidsWOStatus.includes(g)
-                          ? guidsWOStatus
-                          : [...guidsWOStatus, g],
-                    };
-                  },
-                  {
-                    workloadEntitiesGuids: [],
-                    guidsWOStatus: acc.workloadEntities,
-                  }
-                );
-              return {
-                ...acc,
-                workloads: {
-                  ...acc.workloads,
-                  [cur]: workloadEntitiesGuids,
-                },
-                workloadEntities: guidsWOStatus,
-              };
-            } else {
-              return acc;
-            }
-          },
-          { workloads: {}, workloadEntities: [] }
-        );
-        if (Object.keys(workloads).length && workloadEntities.length) {
-          const workloadEntitiesStatuses = await fetchEntitiesStatus(
-            workloadEntities,
-            timeWindow,
-            true
-          );
-          const key =
-            timeWindow?.start && timeWindow?.end
-              ? 'alertViolations'
-              : 'recentAlertViolations';
-          Object.keys(workloads).forEach((wlg) => {
-            entitiesStatusesObj[wlg][key] = workloads[wlg]?.reduce(
-              (acc, cur) => [
-                ...acc,
-                ...(entitesGuidsArray[cur]?.[key] ||
-                  workloadEntitiesStatuses[cur]?.[key] ||
-                  []),
-              ],
-              entitiesStatusesObj[wlg][key] || []
-            );
-          });
-        }
 
         if (isForCache) return entitiesStatusesObj;
         if (statusTimeoutDelay.current && !timeWindow) {
@@ -535,14 +478,71 @@ const Stages = forwardRef(
           }
           setIsLoading(true);
 
+          const { [SIGNAL_TYPES.ENTITY]: entitiesGuids = [] } = guids;
+          const workloads = entitiesGuids?.reduce((acc, cur) => {
+            const [acctId, domain, type] = atob(cur)?.split('|') || [];
+            return acctId && isWorkload({ domain, type })
+              ? {
+                  ...acc,
+                  [acctId]: [...(acc[acctId] || []), cur],
+                }
+              : acc;
+          }, {});
+          let workloadsStatuses = {};
+          if (Object.keys(workloads)?.length) {
+            const { data: { actor: w = {} } = {}, error } =
+              await NerdGraphQuery.query({
+                query: workloadsStatusesQuery(workloads, {
+                  start: fifteenMinutesAgo(timeBands?.[0]?.start),
+                  end: timeBands?.[timeBands.length - 1]?.end,
+                }),
+              });
+            if (!error && w) {
+              workloadsStatuses = Object.keys(w)?.reduce((acc, key) => {
+                if (key === '__typename') return acc;
+                const r = w[key].results || [];
+                return {
+                  ...acc,
+                  ...r.reduce(
+                    (acc2, { statusValueCode, timestamp, workloadGuid }) => ({
+                      ...acc2,
+                      [workloadGuid]: [
+                        ...(acc2[workloadGuid] || []),
+                        { statusValueCode, timestamp },
+                      ],
+                    }),
+                    {}
+                  ),
+                };
+              }, {});
+            }
+          }
+
           timeBands.forEach(async (timeWindow, idx) => {
             const { key, alertsStatusesObj } = timeBandsDataArray[idx] || {};
             const timeWindowCachedData = timeBandDataCache.current.get(key);
             if (!timeWindowCachedData) {
-              const { [SIGNAL_TYPES.ENTITY]: entitiesGuids = [] } = guids;
-              const entitiesStatusesObj = entitiesGuids.length
+              let entitiesStatusesObj = entitiesGuids.length
                 ? await fetchEntitiesStatus(entitiesGuids, timeWindow, true)
                 : {};
+              entitiesStatusesObj = Object.keys(entitiesStatusesObj)?.reduce(
+                (acc, cur) => {
+                  const e = entitiesStatusesObj[cur];
+                  if (isWorkload(e))
+                    return {
+                      ...acc,
+                      [cur]: {
+                        ...e,
+                        statusValueCode: getWorstWorkloadStatusValue(
+                          workloadsStatuses[e.guid],
+                          timeWindow
+                        ),
+                      },
+                    };
+                  return { ...acc, [cur]: e };
+                },
+                {}
+              );
               const timeWindowStatuses = {
                 [SIGNAL_TYPES.ENTITY]: entitiesStatusesObj,
                 [SIGNAL_TYPES.ALERT]: alertsStatusesObj,

src/constants/entities.js

@@ -1 +1,4 @@
-export const WORKLOAD_TYPE = 'WORKLOAD';
+export const WORKLOAD = {
+  DOMAIN: 'NR1',
+  TYPE: 'WORKLOAD',
+};

src/constants/ui-content.js

@@ -139,6 +139,8 @@ export const UI_CONTENT = {
         'No open incidents. Showing the most recent incident.',
       ALERTING_SL_NO_INCIDENT:
         "This Service Level is in an unhealthy state, however we can't find any correlated incidents. It is likely that the Service Level is out of compliance - to investigate further, please open the entity view (linked above).",
+      WORKLOAD_RULES_DISCLAIMER:
+        'Please note that if your workload has custom health status rules, it is possible that some issues listed here may not be applicable to the workload health. You can review your workload health status rules to confirm.',
     },
     TOOLTIP: {
       WORKLOAD_UNKNOWN: 'The status of this workload is unknown',