remove parseLatency and evalLatency

Author: yishi3-db

pkg/queryfrontend/protection_middleware.go

@@ -22,44 +22,24 @@ type protectionMiddleware struct {
 	next         queryrange.Handler
 	engine       *ProtectionEngine
 	logger       log.Logger
-	parseLatency prometheus.Histogram
-	evalLatency  prometheus.Histogram
 	totalLatency prometheus.Histogram
 }
 
 // NewProtectionMiddleware creates a new middleware that applies protection rules to queries.
 func NewProtectionMiddleware(engine *ProtectionEngine, logger log.Logger, reg prometheus.Registerer) queryrange.Middleware {
-	durationBuckets := []float64{0.0001, 0.00025, 0.0005, 0.001, 0.005, 0.01, 0.1, 1.0, 10.0}
-
-	parseLatency := promauto.With(reg).NewHistogram(prometheus.HistogramOpts{
-		Namespace: "thanos",
-		Subsystem: "query_frontend",
-		Name:      "protection_parse_duration_seconds",
-		Help:      "Duration of PromQL parsing in the protection middleware.",
-		Buckets:   durationBuckets,
-	})
-	evalLatency := promauto.With(reg).NewHistogram(prometheus.HistogramOpts{
-		Namespace: "thanos",
-		Subsystem: "query_frontend",
-		Name:      "protection_evaluate_duration_seconds",
-		Help:      "Duration of rule evaluation in the protection middleware.",
-		Buckets:   durationBuckets,
-	})
 	totalLatency := promauto.With(reg).NewHistogram(prometheus.HistogramOpts{
 		Namespace: "thanos",
 		Subsystem: "query_frontend",
 		Name:      "protection_duration_seconds",
 		Help:      "Total duration of the protection middleware, including parsing and evaluation.",
-		Buckets:   durationBuckets,
+		Buckets:   []float64{0.0001, 0.00025, 0.0005, 0.001, 0.005, 0.01, 0.1, 1.0, 10.0},
 	})
 
 	return queryrange.MiddlewareFunc(func(next queryrange.Handler) queryrange.Handler {
 		return &protectionMiddleware{
 			next:         next,
 			engine:       engine,
 			logger:       logger,
-			parseLatency: parseLatency,
-			evalLatency:  evalLatency,
 			totalLatency: totalLatency,
 		}
 	})
@@ -74,11 +54,8 @@ func (m *protectionMiddleware) Do(ctx context.Context, r queryrange.Request) (qu
 	totalStart := time.Now()
 	defer func() { m.totalLatency.Observe(time.Since(totalStart).Seconds()) }()
 
-	// Parse PromQL and measure latency.
-	parseStart := time.Now()
+	// Parse PromQL.
 	parsed, err := extpromql.ParseExpr(query)
-	m.parseLatency.Observe(time.Since(parseStart).Seconds())
-
 	if err != nil {
 		// Malformed query: let downstream handle it, don't block.
 		level.Debug(m.logger).Log("msg", "protection middleware: failed to parse query, skipping", "err", err)
@@ -95,9 +72,7 @@ func (m *protectionMiddleware) Do(ctx context.Context, r queryrange.Request) (qu
 	}
 
 	// Evaluate all protection rules.
-	evalStart := time.Now()
 	protectionResult, err := m.engine.Evaluate(ctx, req)
-	m.evalLatency.Observe(time.Since(evalStart).Seconds())
 
 	if err != nil {
 		return nil, errors.Wrap(err, "protection engine evaluation failed")