SceneDataTransformer: Check metadata when choosing to emit transformation data

packages/scenes/src/querying/SceneDataTransformer.test.ts

@@ -738,6 +738,92 @@ describe('SceneDataTransformer', () => {
       expect(customTransformerSpy).toHaveBeenCalledTimes(1);
       expect(transformer.state.data?.state).toBe(LoadingState.Loading);
     });
+
+    it('emits updated metadata when transformed frame references are unchanged', async () => {
+      const series = [arrayToDataFrame([1, 2, 3])];
+      const annotations: DataFrame[] = [];
+      const dataNode = new SceneDataNode({
+        data: {
+          state: LoadingState.Done,
+          timeRange: getDefaultTimeRange(),
+          request: { requestId: 'SQR100' } as DataQueryRequest,
+          series,
+          annotations,
+        },
+      });
+
+      const transformer = new SceneDataTransformer({
+        $data: dataNode,
+        transformations: [customTransformOperator],
+      });
+
+      const results: PanelData[] = [];
+      transformer.getResultsStream().subscribe((result) => {
+        results.push(result.data);
+      });
+
+      transformer.activate();
+
+      await new Promise((r) => setTimeout(r, 1));
+
+      const initialResult = results[0];
+
+      dataNode.setState({
+        data: {
+          ...dataNode.state.data,
+          state: LoadingState.Loading,
+          request: { requestId: 'SQR101' } as DataQueryRequest,
+        },
+      });
+
+      await new Promise((r) => setTimeout(r, 1));
+
+      expect(customTransformerSpy).toHaveBeenCalledTimes(1);
+      expect(results).toHaveLength(2);
+      expect(results[1].state).toBe(LoadingState.Loading);
+      expect(results[1].request?.requestId).toBe('SQR101');
+      expect(results[1].series).toBe(initialResult.series);
+      expect(results[1].annotations).toBe(initialResult.annotations);
+    });
+
+    it('does not emit when transformed frame references and metadata are unchanged', async () => {
+      const series = [arrayToDataFrame([1, 2, 3])];
+      const annotations: DataFrame[] = [];
+      const dataNode = new SceneDataNode({
+        data: {
+          state: LoadingState.Done,
+          timeRange: getDefaultTimeRange(),
+          request: { requestId: 'SQR100' } as DataQueryRequest,
+          series,
+          annotations,
+        },
+      });
+
+      const transformer = new SceneDataTransformer({
+        $data: dataNode,
+        transformations: [customTransformOperator],
+      });
+
+      const results: PanelData[] = [];
+      transformer.getResultsStream().subscribe((result) => {
+        results.push(result.data);
+      });
+
+      transformer.activate();
+
+      await new Promise((r) => setTimeout(r, 1));
+
+      dataNode.setState({
+        data: {
+          ...dataNode.state.data,
+        },
+      });
+
+      await new Promise((r) => setTimeout(r, 1));
+
+      expect(customTransformerSpy).toHaveBeenCalledTimes(1);
+      expect(results).toHaveLength(1);
+    });
   });
 
   it('interpolates transformation options before applying', () => {

packages/scenes/src/querying/SceneDataTransformer.ts

@@ -1,3 +1,4 @@
+import { isEqual } from 'lodash';
 import {
   CustomTransformOperator,
   DataFrame,
@@ -177,9 +178,27 @@ export class SceneDataTransformer extends SceneObjectBase<SceneDataTransformerSt
     const { series, annotations } = this._prevDataFromSource;
 
     if (data.series === series && data.annotations === annotations) {
-      if (this.state.data && data.state !== this.state.data.state) {
-        this.setState({ data: { ...this.state.data, state: data.state } });
+      if (this.state.data) {
+        const currentData = this.state.data;
+        const nextData: PanelData = {
+          ...data,
+          series: currentData.series,
+          annotations: currentData.annotations,
+        };
+
+        const metadataChanged =
+          currentData.state !== nextData.state ||
+          currentData.request?.requestId !== nextData.request?.requestId ||
+          currentData.error !== nextData.error ||
+          !isEqual(currentData.errors, nextData.errors) ||
+          !isEqual(currentData.timeRange, nextData.timeRange);
+
+        if (metadataChanged) {
+          this.setState({ data: nextData });
+          this._results.next({ origin: this, data: nextData });
+        }
       }
+
       return true;
     }