[feat][backend]: refactor offline metric & support space_id skip (#404)

* feat(backend): refactor

* feat(backend): add ut

Author: kidkidkid

backend/modules/observability/application/convertor/metric/metric.go

@@ -4,9 +4,18 @@
 package metric
 
 import (
+	"sort"
+	"strings"
+
 	"github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/observability/domain/metric"
 	"github.com/coze-dev/coze-loop/backend/modules/observability/domain/metric/entity"
 	"github.com/coze-dev/coze-loop/backend/pkg/lang/ptr"
+	"github.com/samber/lo"
+)
+
+const (
+	maxPieCount = 10000
+	retPieCount = 1000
 )
 
 func MetricPointDO2DTO(m *entity.MetricPoint) *metric.MetricPoint {
@@ -41,6 +50,9 @@ func MetricDO2DTO(m *entity.Metric) *metric.Metric {
 		}
 		ret.TimeSeries[k] = MetricPointListDO2DTO(v)
 	}
+	if len(ret.Pie) > retPieCount {
+		ret.Pie = minimizePie(ret.Pie)
+	}
 	return ret
 }
 
@@ -53,3 +65,30 @@ func CompareDTO2DO(c *metric.Compare) *entity.Compare {
 		Shift: ptr.From(c.ShiftSeconds),
 	}
 }
+
+func minimizePie(pie map[string]string) map[string]string {
+	if len(pie) > maxPieCount {
+		for k, v := range pie {
+			if v == "0" || v == "1" {
+				delete(pie, k)
+			}
+		}
+	}
+	if len(pie) > retPieCount {
+		keys := lo.Keys(pie)
+		// 假设没有浮点数, pie都是整数
+		sort.Slice(keys, func(i, j int) bool {
+			a, b := pie[keys[i]], pie[keys[j]]
+			if len(a) != len(b) {
+				return len(a) > len(b)
+			}
+			return strings.Compare(a, b) > 0
+		})
+		ret := make(map[string]string)
+		for _, key := range keys[:retPieCount] {
+			ret[key] = pie[key]
+		}
+		pie = ret
+	}
+	return pie
+}

backend/modules/observability/application/convertor/metric/metric_test.go

@@ -0,0 +1,129 @@
+// Copyright (c) 2026 coze-dev Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package metric
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMinimizePie(t *testing.T) {
+	t.Run("size <= 1000 should not change", func(t *testing.T) {
+		pie := make(map[string]string)
+		for i := 0; i < 500; i++ {
+			pie[fmt.Sprintf("key-%d", i)] = "1"
+		}
+		result := minimizePie(pie)
+		assert.Equal(t, 500, len(result))
+	})
+
+	t.Run("size > 1000 should truncate by custom sort", func(t *testing.T) {
+		pie := make(map[string]string)
+		// Add 1000 items with value "1" (length 1)
+		for i := 0; i < 1000; i++ {
+			pie[fmt.Sprintf("small-%d", i)] = "2"
+		}
+
+		// Add 5 items with value "100" (length 3)
+		for i := 0; i < 5; i++ {
+			pie[fmt.Sprintf("large-%d", i)] = "100"
+		}
+
+		// Add 5 items with value "10" (length 2)
+		for i := 0; i < 5; i++ {
+			pie[fmt.Sprintf("medium-%d", i)] = "91"
+		}
+
+		// Total 1010 items.
+		// Sort order desc: "100" (len 3) > "10" (len 2) > "1" (len 1)
+		// Expected kept:
+		// 5 "large" items (len 3)
+		// 5 "medium" items (len 2)
+		// 990 "small" items (len 1)
+		// Total kept: 1000.
+		// Removed: 10 "small" items.
+
+		result := minimizePie(pie)
+		assert.Equal(t, 1000, len(result))
+
+		// Verify large and medium are kept
+		for i := 0; i < 5; i++ {
+			_, ok := result[fmt.Sprintf("large-%d", i)]
+			assert.True(t, ok, "large item %d missing", i)
+			_, ok = result[fmt.Sprintf("medium-%d", i)]
+			assert.True(t, ok, "medium item %d missing", i)
+		}
+
+		// Verify some small items are removed.
+		// Since map iteration order is random when building the slice,
+		// and the sort is stable for equal values (depends on implementation, actually sort.Slice is not guaranteed stable,
+		// but here values are identical "1").
+		// Wait, if values are identical "1", their relative order is undefined after sort.
+		// So we can't deterministically say WHICH "small" items are removed, only that 10 are removed.
+
+		removedCount := 0
+		for i := 0; i < 1000; i++ {
+			if _, ok := result[fmt.Sprintf("small-%d", i)]; !ok {
+				removedCount++
+			}
+		}
+		fmt.Println("===", removedCount)
+		assert.Equal(t, 10, removedCount)
+	})
+
+	t.Run("size > 10000 should filter 0 and 1 first", func(t *testing.T) {
+		pie := make(map[string]string)
+		// 5000 items with "0"
+		for i := 0; i < 5000; i++ {
+			pie[fmt.Sprintf("zero-%d", i)] = "0"
+		}
+		// 5000 items with "1"
+		for i := 0; i < 5000; i++ {
+			pie[fmt.Sprintf("one-%d", i)] = "1"
+		}
+		// 500 items with "2"
+		for i := 0; i < 500; i++ {
+			pie[fmt.Sprintf("two-%d", i)] = "2"
+		}
+
+		// Total 10500.
+		// Filter "0" and "1" -> removes 10000 items.
+		// Remaining 500 items with "2".
+		// 500 <= 1000, so no truncation.
+
+		result := minimizePie(pie)
+		assert.Equal(t, 500, len(result))
+
+		for k, v := range result {
+			assert.Equal(t, "2", v)
+			assert.Contains(t, k, "two-")
+		}
+	})
+
+	t.Run("size > 10000 filter 0 and 1 then truncate", func(t *testing.T) {
+		pie := make(map[string]string)
+		// 9000 items with "1"
+		for i := 0; i < 9000; i++ {
+			pie[fmt.Sprintf("one-%d", i)] = "1"
+		}
+		// 1500 items with "2"
+		for i := 0; i < 1500; i++ {
+			pie[fmt.Sprintf("two-%d", i)] = "2"
+		}
+
+		// Total 10500.
+		// Filter "1" -> removes 9000 items.
+		// Remaining 1500 items with "2".
+		// 1500 > 1000, truncate to 1000.
+
+		result := minimizePie(pie)
+		assert.Equal(t, 1000, len(result))
+
+		for _, v := range result {
+			assert.Equal(t, "2", v)
+		}
+	})
+}

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

@@ -114,8 +114,13 @@ type ConsumerListening struct {
 }
 
 type MetricQueryConfig struct {
-	SupportOffline       bool `mapstructure:"support_offline" json:"support_offline"`
-	OfflineCriticalPoint int  `mapstructure:"offline_critical_point" json:"offline_critical_point"`
+	SupportOffline       bool                    `mapstructure:"support_offline" json:"support_offline"`
+	OfflineCriticalPoint int                     `mapstructure:"offline_critical_point" json:"offline_critical_point"`
+	SpaceConfigs         map[string]*SpaceConfig `mapstructure:"space_configs" json:"space_configs"`
+}
+
+type SpaceConfig struct {
+	DisableQuery bool `mapstructure:"disable_query" json:"disable_query"`
 }
 
 //go:generate mockgen -destination=mocks/config.go -package=mocks . ITraceConfig

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

@@ -251,6 +251,11 @@ func (m *MetricsService) QueryMetrics(ctx context.Context, req *QueryMetricsReq)
 	if len(req.MetricsNames) == 0 {
 		return &QueryMetricsResp{}, nil
 	}
+	qCfg := m.traceConfig.GetMetricQueryConfig(ctx)
+	val := qCfg.SpaceConfigs[strconv.FormatInt(req.WorkspaceID, 10)]
+	if val != nil && val.DisableQuery {
+		return &QueryMetricsResp{}, nil
+	}
 	for _, metricName := range req.MetricsNames {
 		mVal, ok := m.metricDefMap[metricName]
 		if !ok {

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

@@ -227,6 +227,37 @@ func TestMetricsService_QueryMetrics(t *testing.T) {
 		assert.Error(t, err)
 		assert.Nil(t, resp)
 	})
+
+	t.Run("query disabled", func(t *testing.T) {
+		t.Parallel()
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		traceConfigMock := configmocks.NewMockITraceConfig(ctrl)
+		pMetrics := &entity.PlatformMetrics{
+			MetricGroups:       map[string]*entity.MetricGroup{},
+			DrillDownObjects:   map[string]*loop_span.FilterField{},
+			PlatformMetricDefs: map[loop_span.PlatformType]*entity.PlatformMetricDef{},
+		}
+
+		traceConfigMock.EXPECT().GetMetricQueryConfig(gomock.Any()).Return(&config.MetricQueryConfig{
+			SpaceConfigs: map[string]*config.SpaceConfig{
+				"1": {DisableQuery: true},
+			},
+		}).AnyTimes()
+
+		svc, err := NewMetricsService(repomocks.NewMockIMetricRepo(ctrl), nil, tenantmocks.NewMockITenantProvider(ctrl), traceServicemocks.NewMockTraceFilterProcessorBuilder(ctrl), traceConfigMock, pMetrics)
+		assert.NoError(t, err)
+
+		resp, err := svc.QueryMetrics(context.Background(), &QueryMetricsReq{
+			PlatformType: loop_span.PlatformType("loop"),
+			WorkspaceID:  1,
+			MetricsNames: []string{"metric_a"},
+		})
+		assert.NoError(t, err)
+		assert.NotNil(t, resp)
+		assert.Empty(t, resp.Metrics)
+	})
 }
 
 type testMetricDefinition struct {