feat(runtime-datasource): add runtime datasource (#649)

* feat(runtime-datasource): add runtime datasource

* feat(runtime-datasource): add error check

src/module.ts

@@ -2,6 +2,7 @@ import { AppPlugin } from '@grafana/data';
 import { App } from 'Components/App';
 import init from '@bsull/augurs';
 import { linkConfigs } from 'services/extensions/links';
+import { init as initRuntimeDs } from 'services/datasource';
 
 // eslint-disable-next-line no-console
 init().then(() => console.debug('Grafana ML initialized'));
@@ -11,3 +12,5 @@ export const plugin = new AppPlugin<{}>().setRootPage(App);
 for (const linkConfig of linkConfigs) {
   plugin.configureExtensionLink(linkConfig);
 }
+
+initRuntimeDs();

src/services/datasource.ts

@@ -0,0 +1,57 @@
+import { DataQueryRequest, DataQueryResponse, TestDataSourceResponse } from '@grafana/data';
+import { getDataSourceSrv } from '@grafana/runtime';
+import { RuntimeDataSource, SceneObject, sceneUtils } from '@grafana/scenes';
+import { DataQuery } from '@grafana/schema';
+import { Observable, isObservable } from 'rxjs';
+import { getDataSource } from './scenes';
+
+export const WRAPPED_LOKI_DS_UID = 'wrapped-loki-ds-uid';
+
+type SceneDataQueryRequest = DataQueryRequest<DataQuery> & {
+  scopedVars?: { __sceneObject?: { valueOf: () => SceneObject } };
+};
+
+class WrappedLokiDatasource extends RuntimeDataSource<DataQuery> {
+  constructor(pluginId: string, uid: string) {
+    super(pluginId, uid);
+  }
+
+  query(request: SceneDataQueryRequest): Promise<DataQueryResponse> | Observable<DataQueryResponse> {
+    return new Observable<DataQueryResponse>((subscriber) => {
+      if (!request.scopedVars?.__sceneObject) {
+        throw new Error('Scene object not found in request');
+      }
+
+      getDataSourceSrv()
+        .get(getDataSource(request.scopedVars.__sceneObject.valueOf()))
+        .then((ds) => {
+          // override the target datasource to Loki
+          request.targets = request.targets.map((target) => {
+            target.datasource = ds;
+            return target;
+          });
+
+          // query the datasource and return either observable or promise
+          const dsResponse = ds.query(request);
+          if (isObservable(dsResponse)) {
+            dsResponse.subscribe(subscriber);
+          } else {
+            dsResponse.then((response) => {
+              subscriber.next(response);
+              subscriber.complete();
+            });
+          }
+        });
+    });
+  }
+
+  testDatasource(): Promise<TestDataSourceResponse> {
+    return Promise.resolve({ status: 'success', message: 'Data source is working', title: 'Success' });
+  }
+}
+
+export function init() {
+  sceneUtils.registerRuntimeDataSource({
+    dataSource: new WrappedLokiDatasource('wrapped-loki-ds', WRAPPED_LOKI_DS_UID),
+  });
+}

src/services/panel.ts

@@ -2,8 +2,8 @@ import { DataFrame, FieldConfig, FieldMatcherID } from '@grafana/data';
 import { FieldConfigOverridesBuilder, SceneDataTransformer, SceneQueryRunner } from '@grafana/scenes';
 import { map, Observable } from 'rxjs';
 import { LokiQuery } from './query';
-import { EXPLORATION_DS } from './variables';
 import { HideSeriesConfig } from '@grafana/schema';
+import { WRAPPED_LOKI_DS_UID } from './datasource';
 
 const UNKNOWN_LEVEL_LOGS = 'logs';
 export function setLeverColorOverrides(overrides: FieldConfigOverridesBuilder<FieldConfig>) {
@@ -86,15 +86,15 @@ export function getQueryRunner(query: LokiQuery) {
   if (query.legendFormat?.toLowerCase().includes('level')) {
     return new SceneDataTransformer({
       $data: new SceneQueryRunner({
-        datasource: EXPLORATION_DS,
+        datasource: { uid: WRAPPED_LOKI_DS_UID },
         queries: [query],
       }),
       transformations: [sortLevelTransformation],
     });
   }
 
   return new SceneQueryRunner({
-    datasource: EXPLORATION_DS,
+    datasource: { uid: WRAPPED_LOKI_DS_UID },
     queries: [query],
   });
 }

src/services/scenes.ts

@@ -17,8 +17,8 @@ export function getUrlForValues(values: SceneObjectUrlValues) {
   return urlUtil.renderUrl(EXPLORATIONS_ROUTE, values);
 }
 
-export function getDataSource(exploration: IndexScene) {
-  return sceneGraph.interpolate(exploration, VAR_DATASOURCE_EXPR);
+export function getDataSource(sceneObject: SceneObject) {
+  return sceneGraph.interpolate(sceneObject, VAR_DATASOURCE_EXPR);
 }
 
 export function getQueryExpr(exploration: IndexScene) {