feat(backend): refactor

Author: kidkidkid

backend/modules/observability/domain/component/config/config.go

@@ -118,6 +118,10 @@ type MetricQueryConfig struct {
 	OfflineCriticalPoint int  `mapstructure:"offline_critical_point" json:"offline_critical_point"`
 }
 
+type MetricOfflineCalculateConfig struct {
+	SkipSpaceIds []string `mapstructure:"skip_space_ids" json:"skip_space_ids"`
+}
+
 //go:generate mockgen -destination=mocks/config.go -package=mocks . ITraceConfig
 type ITraceConfig interface {
 	GetSystemViews(ctx context.Context) ([]*SystemView, error)
@@ -138,6 +142,7 @@ type ITraceConfig interface {
 	GetSpanWithAnnotationMqProducerCfg(ctx context.Context) (*MqProducerCfg, error)
 	GetMetricPlatformTenants(ctx context.Context) (*PlatformTenantsCfg, error)
 	GetMetricQueryConfig(ctx context.Context) *MetricQueryConfig
+	GetMetricOfflineCalculateConfig(ctx context.Context) MetricOfflineCalculateConfig
 
 	conf.IConfigLoader
 }

backend/modules/observability/domain/component/config/mocks/config.go

@@ -442,6 +442,25 @@ func (m *MetricsService) buildOnlineMetricQuery(ctx context.Context, req *QueryM
 			return nil
 		})
 		mBuilder.mRepoReq.Source = repo.MetricSourceOffline
+		// add more filter
+		cfg := m.traceConfig.GetMetricOfflineCalculateConfig(ctx)
+		if len(cfg.SkipSpaceIds) > 0 {
+			param.Filters = &loop_span.FilterFields{
+				QueryAndOr: ptr.Of(loop_span.QueryAndOrEnumAnd),
+				FilterFields: []*loop_span.FilterField{
+					{
+						FieldName: loop_span.SpanFieldSpaceId,
+						FieldType: loop_span.FieldTypeString,
+						Values:    cfg.SkipSpaceIds,
+						QueryType: ptr.Of(loop_span.QueryTypeEnumNotIn),
+					},
+					{
+						QueryAndOr: ptr.Of(loop_span.QueryAndOrEnumAnd),
+						SubFilter:  param.Filters,
+					},
+				},
+			}
+		}
 	}
 	return mBuilder, nil
 }

backend/modules/observability/domain/metric/service/metric.go

@@ -642,3 +642,106 @@ func TestGetMetricGroupBy(t *testing.T) {
 		assert.Contains(t, err.Error(), "groupby dimension has no alias")
 	})
 }
+
+func TestQueryMetrics_GroupBySpaceID_SkipSpaceIds(t *testing.T) {
+	t.Parallel()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	repoMock := repomocks.NewMockIMetricRepo(ctrl)
+	tenantMock := tenantmocks.NewMockITenantProvider(ctrl)
+	builderMock := traceServicemocks.NewMockTraceFilterProcessorBuilder(ctrl)
+	filterMock := spanfiltermocks.NewMockFilter(ctrl)
+	traceConfigMock := configmocks.NewMockITraceConfig(ctrl)
+
+	// Setup mocks
+	tenantMock.EXPECT().GetMetricTenantsByPlatformType(gomock.Any(), gomock.Any()).Return([]string{"tenant-1"}, nil)
+	builderMock.EXPECT().BuildPlatformRelatedFilter(gomock.Any(), gomock.Any()).Return(filterMock, nil)
+
+	// BuildBasicSpanFilter returns filter with SpaceId=0
+	filterMock.EXPECT().BuildBasicSpanFilter(gomock.Any(), gomock.Any()).DoAndReturn(
+		func(_ context.Context, env *spanfilter.SpanEnv) ([]*loop_span.FilterField, bool, error) {
+			return []*loop_span.FilterField{
+				{
+					FieldName: loop_span.SpanFieldSpaceId,
+					Values:    []string{"0"},
+				},
+			}, true, nil
+		},
+	)
+
+	// TraceConfig returns SkipSpaceIds
+	traceConfigMock.EXPECT().GetMetricOfflineCalculateConfig(gomock.Any()).Return(config.MetricOfflineCalculateConfig{
+		SkipSpaceIds: []string{"space_skip_1", "space_skip_2"},
+	})
+	traceConfigMock.EXPECT().GetMetricQueryConfig(gomock.Any()).Return(&config.MetricQueryConfig{
+		SupportOffline: false,
+	}).AnyTimes()
+
+	requestFilter := &loop_span.FilterFields{
+		FilterFields: []*loop_span.FilterField{
+			{FieldName: "some_req_field", Values: []string{"val"}},
+		},
+	}
+
+	// Assert that filters are modified
+	repoMock.EXPECT().GetMetrics(gomock.Any(), gomock.Any()).DoAndReturn(
+		func(_ context.Context, param *repo.GetMetricsParam) (*repo.GetMetricsResult, error) {
+			assert.NotNil(t, param.Filters)
+			assert.Equal(t, loop_span.QueryAndOrEnumAnd, *param.Filters.QueryAndOr)
+			// Should have 2 fields: space_id not in, and requestFilter
+			assert.Len(t, param.Filters.FilterFields, 2)
+
+			// Check first field: space_id not in skip_ids
+			f1 := param.Filters.FilterFields[0]
+			assert.Equal(t, loop_span.SpanFieldSpaceId, f1.FieldName)
+			assert.NotNil(t, f1.QueryType)
+			assert.Equal(t, loop_span.QueryTypeEnumNotIn, *f1.QueryType)
+			assert.ElementsMatch(t, []string{"space_skip_1", "space_skip_2"}, f1.Values)
+
+			// Check second field: requestFilter
+			f2 := param.Filters.FilterFields[1]
+			assert.Equal(t, loop_span.QueryAndOrEnumAnd, *f2.QueryAndOr)
+			assert.Equal(t, requestFilter, f2.SubFilter)
+
+			return &repo.GetMetricsResult{
+				Data: []map[string]any{},
+			}, nil
+		},
+	)
+
+	metricDef := &testMetricDefinition{
+		name:       "metric_a",
+		metricType: entity.MetricTypeTimeSeries,
+		where:      []*loop_span.FilterField{},
+	}
+	pMetrics := &entity.PlatformMetrics{
+		MetricGroups: map[string]*entity.MetricGroup{
+			"test_group": {
+				MetricDefinitions: []entity.IMetricDefinition{metricDef},
+			},
+		},
+		DrillDownObjects: map[string]*loop_span.FilterField{},
+		PlatformMetricDefs: map[loop_span.PlatformType]*entity.PlatformMetricDef{
+			loop_span.PlatformType("loop"): {
+				MetricGroups: []string{"test_group"},
+			},
+		},
+	}
+
+	svc, err := NewMetricsService(repoMock, nil, tenantMock, builderMock, traceConfigMock, pMetrics)
+	assert.NoError(t, err)
+
+	_, err = svc.QueryMetrics(context.Background(), &QueryMetricsReq{
+		PlatformType:   loop_span.PlatformType("loop"),
+		WorkspaceID:    1,
+		MetricsNames:   []string{"metric_a"},
+		Granularity:    entity.MetricGranularity1Hour,
+		StartTime:      0,
+		EndTime:        0,
+		GroupBySpaceID: true,
+		FilterFields:   requestFilter,
+	})
+	assert.NoError(t, err)
+}
+

backend/modules/observability/domain/metric/service/metric_test.go

@@ -1105,6 +1105,7 @@ func TestMetricsService_TraverseMetrics(t *testing.T) {
 		traceCfgMock.EXPECT().GetMetricQueryConfig(gomock.Any()).Return(&config.MetricQueryConfig{
 			SupportOffline: false,
 		}).AnyTimes()
+		traceCfgMock.EXPECT().GetMetricOfflineCalculateConfig(gomock.Any()).Return(config.MetricOfflineCalculateConfig{}).AnyTimes()
 
 		// 配置 filter 与租户
 		tenantMock.EXPECT().GetMetricTenantsByPlatformType(gomock.Any(), gomock.Any()).Return([]string{"tenant-1"}, nil)

backend/modules/observability/domain/metric/service/offline_metric_test.go

@@ -30,6 +30,7 @@ const (
 	consumerListeningCfgKey            = "consumer_listening"
 	metricPlatformTenantCfgKey         = "metric_platform_tenants"
 	metricQueryConfigKey               = "metric_query_config"
+	metricOfflineCalculateCfgKey       = "metric_offline_calculate_config"
 )
 
 type TraceConfigCenter struct {
@@ -210,6 +211,15 @@ func (t *TraceConfigCenter) GetMetricQueryConfig(ctx context.Context) *config.Me
 	return cfg
 }
 
+func (t *TraceConfigCenter) GetMetricOfflineCalculateConfig(ctx context.Context) config.MetricOfflineCalculateConfig {
+	cfg := new(config.MetricOfflineCalculateConfig)
+	if err := t.UnmarshalKey(ctx, metricOfflineCalculateCfgKey, cfg); err != nil {
+		logs.CtxWarn(ctx, "fail to get metric query cfg, %v", err)
+		return config.MetricOfflineCalculateConfig{}
+	}
+	return *cfg
+}
+
 func NewTraceConfigCenter(confP conf.IConfigLoader) config.ITraceConfig {
 	ret := &TraceConfigCenter{
 		IConfigLoader: confP,