feat/filter-datasource: implement backend part

Author: idrissneumann

pkg/quickwit/client/client.go

@@ -24,6 +24,7 @@ type DatasourceInfo struct {
 	ID                         int64
 	UID                        string
 	Name                       string
+	ForcedQueryFilter          string
 	LogsDatasourceUID          string
 	LogsDatasourceName         string
 	TracesDatasourceUID        string

pkg/quickwit/data_query.go

@@ -14,7 +14,7 @@ const (
 	defaultSize = 100
 )
 
-func buildMSR(queries []*Query, defaultTimeField string) ([]*es.SearchRequest, error) {
+func buildMSR(queries []*Query, defaultTimeField string, forcedQueryFilter string) ([]*es.SearchRequest, error) {
 	ms := es.NewMultiSearchRequestBuilder()
 
 	for _, q := range queries {
@@ -31,7 +31,7 @@ func buildMSR(queries []*Query, defaultTimeField string) ([]*es.SearchRequest, e
 		// trace_id lookups go from "scan every split" to "scan a few" — the
 		// same speedup the native Jaeger endpoint gets via auto-derived bounds.
 		filters.AddDateRangeFilter(defaultTimeField, q.RangeTo, q.RangeFrom)
-		filters.AddQueryStringFilter(q.RawQuery, true, "AND")
+		filters.AddQueryStringFilter(applyForcedQueryFilter(q.RawQuery, forcedQueryFilter), true, "AND")
 		if isTraceSearchQuery(q) {
 			filters.AddQueryStringFilter(traceSearchSettingsQuery(q), true, "AND")
 		}
@@ -53,6 +53,20 @@ func buildMSR(queries []*Query, defaultTimeField string) ([]*es.SearchRequest, e
 	return ms.Build()
 }
 
+func applyForcedQueryFilter(rawQuery string, forcedQueryFilter string) string {
+	query := strings.TrimSpace(rawQuery)
+	forced := strings.TrimSpace(forcedQueryFilter)
+
+	if forced == "" {
+		return query
+	}
+	if query == "" {
+		return forced
+	}
+
+	return query + " AND " + forced
+}
+
 func setFloatPath(settings *simplejson.Json, path ...string) {
 	if stringValue, err := settings.GetPath(path...).String(); err == nil {
 		if value, err := strconv.ParseFloat(stringValue, 64); err == nil {

pkg/quickwit/data_query_test.go

@@ -24,6 +24,20 @@ func TestQueryTypeHelpersDoNotPanicWithoutMetrics(t *testing.T) {
 	})
 }
 
+func TestApplyForcedQueryFilter(t *testing.T) {
+	t.Run("adds AND when query is not empty", func(t *testing.T) {
+		assert.Equal(t, "service:api AND tenant:acme", applyForcedQueryFilter("service:api", "tenant:acme"))
+	})
+
+	t.Run("uses only forced filter when query is empty", func(t *testing.T) {
+		assert.Equal(t, "tenant:acme", applyForcedQueryFilter("", "tenant:acme"))
+	})
+
+	t.Run("keeps original query when forced filter is empty", func(t *testing.T) {
+		assert.Equal(t, "service:api", applyForcedQueryFilter("service:api", ""))
+	})
+}
+
 func TestExecuteElasticsearchDataQuery(t *testing.T) {
 	from := time.Date(2018, 5, 15, 17, 50, 0, 0, time.UTC)
 	to := time.Date(2018, 5, 15, 17, 55, 0, 0, time.UTC)
@@ -1801,7 +1815,7 @@ func executeElasticsearchDataQuery(c es.Client, body string, from, to time.Time)
 	if err != nil {
 		return nil, err
 	}
-	req, err := buildMSR(queries, configuredFields.TimeField)
+	req, err := buildMSR(queries, configuredFields.TimeField, "")
 	if err != nil {
 		return &backend.QueryDataResponse{}, err
 	}

pkg/quickwit/elasticsearch.go

@@ -25,7 +25,7 @@ func queryData(ctx context.Context, dataQueries []backend.DataQuery, dsInfo *es.
 
 	// Create a request
 	// NODE : Params should probably be assembled in a dedicated structure to be reused by parseResponse
-	req, err := buildMSR(queries, dsInfo.ConfiguredFields.TimeField)
+	req, err := buildMSR(queries, dsInfo.ConfiguredFields.TimeField, dsInfo.ForcedQueryFilter)
 	if err != nil {
 		return &backend.QueryDataResponse{}, err
 	}

pkg/quickwit/quickwit.go

@@ -67,6 +67,11 @@ func NewQuickwitDatasource(ctx context.Context, settings backend.DataSourceInsta
 		logMessageField = ""
 	}
 
+	forcedQueryFilter, ok := jsonData["forcedQueryFilter"].(string)
+	if !ok {
+		forcedQueryFilter = ""
+	}
+
 	logsDatasourceUID, ok := jsonData["logsDatasourceUid"].(string)
 	if !ok {
 		logsDatasourceUID = ""
@@ -121,6 +126,7 @@ func NewQuickwitDatasource(ctx context.Context, settings backend.DataSourceInsta
 		ID:                         settings.ID,
 		UID:                        settings.UID,
 		Name:                       settings.Name,
+		ForcedQueryFilter:          forcedQueryFilter,
 		LogsDatasourceUID:          logsDatasourceUID,
 		LogsDatasourceName:         logsDatasourceName,
 		TracesDatasourceUID:        tracesDatasourceUID,

src/datasource/base.test.ts

@@ -706,72 +706,4 @@ describe('BaseQuickwitDataSource', () => {
     });
   });
 
-  describe('forced query filter', () => {
-    const datasourceContext = (overrides: Record<string, unknown>) =>
-      Object.assign(Object.create(BaseQuickwitDataSource.prototype), overrides);
-
-    const applyTemplateVariables = (
-      query: ElasticsearchQuery,
-      overrides: Record<string, unknown> = {},
-      filters?: AdHocVariableFilter[]
-    ) => {
-      const context = datasourceContext({
-        fieldTypes: {},
-        forcedQueryFilter: '',
-        getRef: () => ({ type: 'quickwit-quickwit-datasource', uid: 'test' }),
-        templateSrv: {
-          replace: (value: string) => value,
-        },
-        ...overrides,
-      });
-
-      return (BaseQuickwitDataSource.prototype as any).applyTemplateVariables.call(context, query, {}, filters);
-    };
-
-    it('appends forced filter with AND when query is not empty', () => {
-      const result = applyTemplateVariables(
-        {
-          refId: 'A',
-          query: 'service:"api"',
-          metrics: [],
-          bucketAggs: [],
-          filters: [],
-        } as ElasticsearchQuery,
-        { forcedQueryFilter: 'severity_text:error' }
-      );
-
-      expect(result.query).toBe('service:"api" AND severity_text:error');
-    });
-
-    it('uses only forced filter when query is empty', () => {
-      const result = applyTemplateVariables(
-        {
-          refId: 'A',
-          query: '',
-          metrics: [],
-          bucketAggs: [],
-          filters: [],
-        } as ElasticsearchQuery,
-        { forcedQueryFilter: 'severity_text:error' }
-      );
-
-      expect(result.query).toBe('severity_text:error');
-    });
-
-    it('still applies forced filter for single trace lookups', () => {
-      const result = applyTemplateVariables(
-        {
-          refId: 'A',
-          query: 'trace_id:abc123',
-          metrics: [{ id: '1', type: 'traces', settings: { limit: '1000' } }] as any,
-          bucketAggs: [],
-          filters: [],
-        } as ElasticsearchQuery,
-        { forcedQueryFilter: 'tenant:acme' },
-        [{ key: 'service', operator: '=', value: 'frontend' }]
-      );
-
-      expect(result.query).toBe('trace_id:abc123 AND tenant:acme');
-    });
-  });
 });

src/datasource/base.ts

@@ -33,7 +33,6 @@ import { fieldTypeMap, hasWhiteSpace, isSimpleToken } from 'utils';
 import { addAddHocFilter } from 'modifyQuery';
 import { getQueryResponseProcessor } from 'datasource/processResponse';
 import { normalizeInternalLinkQuery } from '@/queryModel';
-import { concatenate } from '@/utils/lucene';
 
 import { SECOND } from 'utils/time';
 import { GConstructor } from 'utils/mixins';
@@ -92,7 +91,6 @@ export class BaseQuickwitDataSource
   timeField: string;
   logMessageField?: string;
   logLevelField?: string;
-  forcedQueryFilter?: string;
   logsDatasourceUid?: string;
   logsDatasourceName?: string;
   tracesDatasourceUid?: string;
@@ -122,7 +120,6 @@ export class BaseQuickwitDataSource
     this.timeField = '';
     this.logMessageField = settingsData.logMessageField || '';
     this.logLevelField = settingsData.logLevelField || '';
-    this.forcedQueryFilter = settingsData.forcedQueryFilter || '';
     this.logsDatasourceUid = settingsData.logsDatasourceUid || '';
     this.logsDatasourceName = settingsData.logsDatasourceName || '';
     this.tracesDatasourceUid = settingsData.tracesDatasourceUid || '';
@@ -669,7 +666,7 @@ export class BaseQuickwitDataSource
     const renderedQuery = (() => {
       let q = this.interpolateLuceneQuery(query.query || '', scopedVars);
       if (isSingleTraceLookup) {
-        return this.addForcedQueryFilter(q);
+        return q;
       }
       const queryFilters = query.filters
         ?.filter((f) => {
@@ -685,7 +682,7 @@ export class BaseQuickwitDataSource
         .map((f) => f.filter);
       q = this.addAdHocFilters(q, queryFilters);
       q = this.addAdHocFilters(q, filters);
-      return this.addForcedQueryFilter(q);
+      return q;
     })();
 
     const expandedQuery = {
@@ -699,10 +696,6 @@ export class BaseQuickwitDataSource
     return normalizeInternalLinkQuery(finalQuery);
   }
 
-  private addForcedQueryFilter(query: string) {
-    return concatenate(query, this.forcedQueryFilter || '', 'AND');
-  }
-
   addAdHocFilters(query: string, adhocFilters?: AdHocVariableFilter[]) {
     if (!adhocFilters) {
       return query;