[Conditionals] Increase performance, switch to TelemetryCollections

src/plugins/condition/ConditionManager.js

@@ -39,7 +39,7 @@ export default class ConditionManager extends EventEmitter {
     this.shouldEvaluateNewTelemetry = this.shouldEvaluateNewTelemetry.bind(this);
 
     this.compositionLoad = this.composition.load();
-    this.subscriptions = {};
+    this.telemetryCollections = {};
     this.telemetryObjects = {};
     this.testData = {
       conditionTestInputs: this.conditionSetDomainObject.configuration.conditionTestData,
@@ -48,55 +48,44 @@ export default class ConditionManager extends EventEmitter {
     this.initialize();
   }
 
-  async requestLatestValue(endpoint) {
-    const options = {
-      size: 1,
-      strategy: 'latest'
-    };
-    const latestData = await this.openmct.telemetry.request(endpoint, options);
+  subscribeToTelemetry(telemetryObject) {
+    const keyString = this.openmct.objects.makeKeyString(telemetryObject.identifier);
 
-    if (!latestData) {
-      throw new Error('Telemetry request failed by returning a falsy response');
-    }
-    if (latestData.length === 0) {
+    if (this.telemetryCollections[keyString]) {
       return;
     }
-    this.telemetryReceived(endpoint, latestData[0]);
-  }
 
-  subscribeToTelemetry(endpoint) {
-    const telemetryKeyString = this.openmct.objects.makeKeyString(endpoint.identifier);
-    if (this.subscriptions[telemetryKeyString]) {
-      return;
-    }
+    const requestOptions = {
+      size: 1,
+      strategy: 'latest'
+    };
 
-    const metadata = this.openmct.telemetry.getMetadata(endpoint);
+    this.telemetryCollections[keyString] = this.openmct.telemetry.requestCollection(
+      telemetryObject,
+      requestOptions
+    );
 
-    this.telemetryObjects[telemetryKeyString] = Object.assign({}, endpoint, {
-      telemetryMetaData: metadata ? metadata.valueMetadatas : []
-    });
+    const metadata = this.openmct.telemetry.getMetadata(telemetryObject);
+    const telemetryMetaData = metadata ? metadata.valueMetadatas : [];
+    const telemetryProcessor = this.telemetryReceived.bind(this, telemetryObject);
 
-    // get latest telemetry value (in case subscription is cached and no new data is coming in)
-    this.requestLatestValue(endpoint);
+    this.telemetryObjects[keyString] = Object.assign({}, telemetryObject, { telemetryMetaData });
+
+    this.telemetryCollections[keyString].on('add', telemetryProcessor);
+    this.telemetryCollections[keyString].load();
 
-    this.subscriptions[telemetryKeyString] = this.openmct.telemetry.subscribe(
-      endpoint,
-      this.telemetryReceived.bind(this, endpoint)
-    );
     this.updateConditionTelemetryObjects();
   }
 
   unsubscribeFromTelemetry(endpointIdentifier) {
-    const id = this.openmct.objects.makeKeyString(endpointIdentifier);
-    if (!this.subscriptions[id]) {
-      console.log('no subscription to remove');
-
+    const keyString = this.openmct.objects.makeKeyString(endpointIdentifier);
+    if (!this.telemetryCollections[keyString]) {
       return;
     }
 
-    this.subscriptions[id]();
-    delete this.subscriptions[id];
-    delete this.telemetryObjects[id];
+    this.telemetryCollections[keyString].destroy();
+    delete this.telemetryCollections[keyString];
+    delete this.telemetryObjects[keyString];
     this.removeConditionTelemetryObjects();
 
     //force re-computation of condition set result as we might be in a state where
@@ -107,7 +96,7 @@ export default class ConditionManager extends EventEmitter {
       this.timeSystems,
       this.openmct.time.getTimeSystem()
     );
-    this.updateConditionResults({ id: id });
+    this.updateConditionResults({ id: keyString });
     this.updateCurrentCondition(latestTimestamp);
 
     if (Object.keys(this.telemetryObjects).length === 0) {
@@ -410,11 +399,13 @@ export default class ConditionManager extends EventEmitter {
     return this.openmct.time.getBounds().end >= currentTimestamp;
   }
 
-  telemetryReceived(endpoint, datum) {
+  telemetryReceived(endpoint, data) {
     if (!this.isTelemetryUsed(endpoint)) {
       return;
     }
 
+    const datum = data[0];
+
     const normalizedDatum = this.createNormalizedDatum(datum, endpoint);
     const timeSystemKey = this.openmct.time.getTimeSystem().key;
     let timestamp = {};
@@ -507,8 +498,9 @@ export default class ConditionManager extends EventEmitter {
   destroy() {
     this.composition.off('add', this.subscribeToTelemetry, this);
     this.composition.off('remove', this.unsubscribeFromTelemetry, this);
-    Object.values(this.subscriptions).forEach((unsubscribe) => unsubscribe());
-    delete this.subscriptions;
+    Object.values(this.telemetryCollections).forEach((telemetryCollection) =>
+      telemetryCollection.destroy()
+    );
 
     this.conditions.forEach((condition) => {
       condition.destroy();

src/plugins/plot/stackedPlot/mixins/objectStyles-mixin.js

@@ -128,36 +128,31 @@
       }
     },
     updateStyle(styleObj) {
-      let elemToStyle = this.getStyleReceiver();
+      const elemToStyle = this.getStyleReceiver();
 
-      if (!styleObj || elemToStyle === undefined) {
+      if (!styleObj || !elemToStyle) {
         return;
       }
 
-      let keys = Object.keys(styleObj);
-
-      keys.forEach((key) => {
-        if (elemToStyle) {
-          if (typeof styleObj[key] === 'string' && styleObj[key].indexOf('__no_value') > -1) {
-            if (elemToStyle.style[key]) {
-              elemToStyle.style[key] = '';
-            }
-          } else {
-            if (
-              !styleObj.isStyleInvisible &&
-              elemToStyle.classList.contains(STYLE_CONSTANTS.isStyleInvisible)
-            ) {
-              elemToStyle.classList.remove(STYLE_CONSTANTS.isStyleInvisible);
-            } else if (
-              styleObj.isStyleInvisible &&
-              !elemToStyle.classList.contains(styleObj.isStyleInvisible)
-            ) {
-              elemToStyle.classList.add(styleObj.isStyleInvisible);
-            }
-
-            elemToStyle.style[key] = styleObj[key];
+      // handle visibility separately
+      if (styleObj.isStyleInvisible !== undefined) {
+        elemToStyle.classList.toggle(STYLE_CONSTANTS.isStyleInvisible, styleObj.isStyleInvisible);
+        delete styleObj.isStyleInvisible;
+      }
+
+      // build style string
+      const styleString = Object.entries(styleObj)
+        .map(([key, value]) => {
+          if (typeof value === 'string' && value.includes('__no_value')) {
+            return `${key}: ;`; // removes the property
           }
-        }
+          return `${key}: ${value};`;
+        })
+        .join(' ');
+
+      // apply styles in one operation
+      requestAnimationFrame(() => {
+        elemToStyle.style.cssText += styleString;
       });
     }
   }