fix: use configured datasource instead of default one

src/datasource/DataSource.test.ts

@@ -1,6 +1,7 @@
+import { config } from '@grafana/runtime';
 import { BASIC_CHECK_ALERTS } from 'test/fixtures/checkAlerts';
 import { BASIC_HTTP_CHECK } from 'test/fixtures/checks';
-import { SM_DATASOURCE } from 'test/fixtures/datasources';
+import { LOGS_DATASOURCE, METRICS_DATASOURCE, SM_DATASOURCE } from 'test/fixtures/datasources';
 import { PRIVATE_PROBE } from 'test/fixtures/probes';
 import { apiRoute, ApiRoutes, getServerRequests } from 'test/handlers';
 import { server } from 'test/server';
@@ -144,4 +145,115 @@ describe('SMDataSource', () => {
     expect(request.headers.get('X-Client-ID')).toEqual(process.env.SM_PLUGIN_ID);
     expect(request.headers.get('X-Client-Version')).toEqual(process.env.SM_PLUGIN_VERSION);
   });
+
+  describe('getLogsDS', () => {
+    beforeEach(() => {
+      config.datasources = {};
+    });
+
+    it('should return the configured datasource when it exists', () => {
+      config.datasources = {
+        [LOGS_DATASOURCE.name]: LOGS_DATASOURCE,
+      };
+
+      const smDataSource = new SMDataSource(SM_DATASOURCE);
+      const result = smDataSource.getLogsDS();
+
+      expect(result).toEqual(LOGS_DATASOURCE);
+      expect(result?.uid).toEqual('P4DC6B4C9A7FFCC6C');
+    });
+
+    it('should fall back to default grafanacloud-logs UID when configured datasource does not exist', () => {
+      const defaultLogsDS = { ...LOGS_DATASOURCE, uid: 'grafanacloud-logs' };
+      config.datasources = {
+        [defaultLogsDS.name]: defaultLogsDS,
+      };
+
+      const smDataSourceWithMissingConfig = new SMDataSource({
+        ...SM_DATASOURCE,
+        jsonData: {
+          ...SM_DATASOURCE.jsonData,
+          logs: {
+            ...SM_DATASOURCE.jsonData.logs,
+            uid: 'non-existent-uid',
+          },
+        },
+      });
+
+      const result = smDataSourceWithMissingConfig.getLogsDS();
+
+      expect(result).toEqual(defaultLogsDS);
+      expect(result?.uid).toEqual('grafanacloud-logs');
+    });
+
+    it('should respect custom datasource configuration', () => {
+      const lbacLogsDS = {
+        ...LOGS_DATASOURCE,
+        uid: 'grafanacloud-logs-lbac',
+        name: 'grafanacloud-ckbedwellksix-logs-lbac',
+      };
+
+      config.datasources = {
+        [lbacLogsDS.name]: lbacLogsDS,
+      };
+
+      const smDataSourceWithLBAC = new SMDataSource({
+        ...SM_DATASOURCE,
+        jsonData: {
+          ...SM_DATASOURCE.jsonData,
+          logs: {
+            ...SM_DATASOURCE.jsonData.logs,
+            uid: 'grafanacloud-logs-lbac',
+            grafanaName: 'grafanacloud-ckbedwellksix-logs-lbac',
+          },
+        },
+      });
+
+      const result = smDataSourceWithLBAC.getLogsDS();
+
+      expect(result).toEqual(lbacLogsDS);
+      expect(result?.uid).toEqual('grafanacloud-logs-lbac');
+    });
+  });
+
+  describe('getMetricsDS', () => {
+    beforeEach(() => {
+      config.datasources = {};
+    });
+
+    it('should return the configured datasource when it exists', () => {
+      config.datasources = {
+        [METRICS_DATASOURCE.name]: METRICS_DATASOURCE,
+      };
+
+      const smDataSource = new SMDataSource(SM_DATASOURCE);
+      const result = smDataSource.getMetricsDS();
+
+      expect(result).toEqual(METRICS_DATASOURCE);
+      expect(result?.uid).toEqual('P4DCEA413A673ADCC');
+    });
+
+    it('should fall back to default grafanacloud-metrics UID when configured datasource does not exist', () => {
+      const defaultMetricsDS = { ...METRICS_DATASOURCE, uid: 'grafanacloud-metrics' };
+      config.datasources = {
+        [defaultMetricsDS.name]: defaultMetricsDS,
+      };
+
+      const smDataSourceWithMissingConfig = new SMDataSource({
+        ...SM_DATASOURCE,
+        jsonData: {
+          ...SM_DATASOURCE.jsonData,
+          metrics: {
+            ...SM_DATASOURCE.jsonData.metrics,
+            uid: 'non-existent-uid',
+          },
+        },
+      });
+
+      const result = smDataSourceWithMissingConfig.getMetricsDS();
+
+      expect(result).toEqual(defaultMetricsDS);
+      expect(result?.uid).toEqual('grafanacloud-metrics');
+    });
+  });
 });

src/datasource/DataSource.ts

@@ -101,20 +101,24 @@ export class SMDataSource extends DataSourceApi<SMQuery, SMOptions> {
   // see https://github.com/grafana/synthetic-monitoring-app/pull/911 for more details
   getMetricsDS() {
     const info = this.instanceSettings.jsonData.metrics;
-    const ds = findLinkedDatasource({ ...info, uid: 'grafanacloud-metrics' });
-    if (ds) {
-      return ds;
+    // First try to use the configured datasource (respects custom configurations)
+    const configuredDs = findLinkedDatasource(info);
+    if (configuredDs) {
+      return configuredDs;
     }
-    return findLinkedDatasource(info);
+    // Fall back to the default Grafana Cloud metrics datasource if configured one doesn't exist
+    return findLinkedDatasource({ ...info, uid: 'grafanacloud-metrics' });
   }
 
   getLogsDS() {
     const info = this.instanceSettings.jsonData.logs;
-    const ds = findLinkedDatasource({ ...info, uid: 'grafanacloud-logs' });
-    if (ds) {
-      return ds;
+    // First try to use the configured datasource (respects custom configurations)
+    const configuredDs = findLinkedDatasource(info);
+    if (configuredDs) {
+      return configuredDs;
     }
-    return findLinkedDatasource(this.instanceSettings.jsonData.logs);
+    // Fall back to the default Grafana Cloud logs datasource if configured one doesn't exist
+    return findLinkedDatasource({ ...info, uid: 'grafanacloud-logs' });
   }
 
   async query(options: DataQueryRequest<SMQuery>): Promise<DataQueryResponse> {

src/datasource/types.ts

@@ -22,6 +22,7 @@ export const defaultQuery: SMQuery = {
 export interface ProvisioningLinkedDatasourceInfo {
   grafanaName: string;
   hostedId: number;
+  uid?: string;
 }
 
 export interface LinkedDatasourceInfo extends ProvisioningLinkedDatasourceInfo {

src/hooks/useAppInitializer.ts

@@ -35,19 +35,28 @@ function getLogsName(provisionedName?: string) {
 
 function findDatasourceByNameAndUid(
   provisionedName: string,
+  configuredUid: string | undefined,
   type: 'loki' | 'prometheus'
 ): {
   byName: DataSourceInstanceSettings<DataSourceJsonData> | undefined;
   byUid: DataSourceInstanceSettings<DataSourceJsonData> | undefined;
 } {
   const byName = config.datasources[provisionedName];
-  const byUid = Object.values(config.datasources).find((ds) => {
-    if (type === 'loki') {
-      return ds.uid === 'grafanacloud-logs';
-    } else {
-      return ds.uid === 'grafanacloud-metrics';
-    }
-  });
+
+  // First try to find by the configured UID (respects custom datasources)
+  let byUid = configuredUid ? Object.values(config.datasources).find((ds) => ds.uid === configuredUid) : undefined;
+
+  // Fall back to default Grafana Cloud UIDs if configured UID doesn't exist
+  if (!byUid) {
+    byUid = Object.values(config.datasources).find((ds) => {
+      if (type === 'loki') {
+        return ds.uid === 'grafanacloud-logs';
+      } else {
+        return ds.uid === 'grafanacloud-metrics';
+      }
+    });
+  }
+
   return {
     byName,
     byUid,
@@ -92,9 +101,13 @@ export const useAppInitializer = (redirectTo?: AppRoutes) => {
   const { jsonData, id } = useMeta();
 
   const metricsName = getMetricsName(jsonData.metrics.grafanaName);
-  const { byName: metricsByName, byUid: metricsByUid } = findDatasourceByNameAndUid(metricsName, 'prometheus');
+  const { byName: metricsByName, byUid: metricsByUid } = findDatasourceByNameAndUid(
+    metricsName,
+    jsonData.metrics.uid,
+    'prometheus'
+  );
   const logsName = getLogsName(jsonData.logs.grafanaName);
-  const { byName: logsByName, byUid: logsByUid } = findDatasourceByNameAndUid(logsName, 'loki');
+  const { byName: logsByName, byUid: logsByUid } = findDatasourceByNameAndUid(logsName, jsonData.logs.uid, 'loki');
   const stackId = jsonData.stackId;
 
   const handleClick = async () => {