style: code cleanup and readability improvements

Signed-off-by: rubywtl <rubyharrisonlee@gmail.com>

Author: rubywtl

pkg/querier/tripperware/logicalplan_gen.go renamed to pkg/querier/tripperware/distributed_query.go

@@ -15,43 +15,40 @@ const (
 	stepBatch = 10
 )
 
-func LogicalPlanGenMiddleware(enablePerStepStats bool, lookBackDelta time.Duration) Middleware {
+func DistributedQueryMiddleware(enablePerStepStats bool, lookBackDelta time.Duration) Middleware {
 	return MiddlewareFunc(func(next Handler) Handler {
-		return logicalPlanGen{
+		return distributedQueryMiddleware{
 			next:               next,
 			enablePerStepStats: enablePerStepStats,
 			lookBackDelta:      lookBackDelta,
 		}
 	})
 }
 
-type logicalPlanGen struct {
+func getStartAndEnd(start time.Time, end time.Time, step time.Duration) (time.Time, time.Time) {
+	if step == 0 {
+		return start, start
+	}
+	return start, end
+}
+
+type distributedQueryMiddleware struct {
 	next               Handler
 	enablePerStepStats bool
 	lookBackDelta      time.Duration
 }
 
-func (l logicalPlanGen) NewLogicalPlan(qs string, start time.Time, end time.Time, step time.Duration) (*logicalplan.Plan, error) {
+func (d distributedQueryMiddleware) newLogicalPlan(qs string, start time.Time, end time.Time, step time.Duration) (*logicalplan.Plan, error) {
 
-	qOpts := query.Options{}
-	if step == 0 {
-		qOpts = query.Options{
-			Start:              start,
-			End:                start,
-			Step:               0,
-			StepsBatch:         stepBatch,
-			LookbackDelta:      l.lookBackDelta,
-			EnablePerStepStats: l.enablePerStepStats,
-		}
-	} else {
-		qOpts = query.Options{
-			Start:              start,
-			End:                end,
-			Step:               step,
-			StepsBatch:         stepBatch,
-			LookbackDelta:      l.lookBackDelta,
-			EnablePerStepStats: l.enablePerStepStats,
-		}
+	start, end = getStartAndEnd(start, end, step)
+
+	qOpts := query.Options{
+		Start:              start,
+		End:                end,
+		Step:               step,
+		StepsBatch:         stepBatch,
+		LookbackDelta:      d.lookBackDelta,
+		EnablePerStepStats: d.enablePerStepStats,
 	}
 
 	expr, err := parser.NewParser(qs, parser.WithFunctions(parser.Functions)).ParseExpr()
@@ -71,7 +68,7 @@ func (l logicalPlanGen) NewLogicalPlan(qs string, start time.Time, end time.Time
 	return &optimizedPlan, nil
 }
 
-func (l logicalPlanGen) Do(ctx context.Context, r Request) (Response, error) {
+func (d distributedQueryMiddleware) Do(ctx context.Context, r Request) (Response, error) {
 	promReq, ok := r.(*PrometheusRequest)
 	if !ok {
 		return nil, httpgrpc.Errorf(http.StatusBadRequest, "invalid request format")
@@ -83,12 +80,12 @@ func (l logicalPlanGen) Do(ctx context.Context, r Request) (Response, error) {
 
 	var err error
 
-	newLogicalPlan, err := l.NewLogicalPlan(promReq.Query, startTime, endTime, step)
+	newLogicalPlan, err := d.newLogicalPlan(promReq.Query, startTime, endTime, step)
 	if err != nil {
 		return nil, err
 	}
 
 	promReq.LogicalPlan = *newLogicalPlan
 
-	return l.next.Do(ctx, r)
+	return d.next.Do(ctx, r)
 }

pkg/querier/tripperware/logical_plan_gen_test.go renamed to pkg/querier/tripperware/distributed_query_test.go

@@ -121,7 +121,7 @@ func TestLogicalPlanGeneration(t *testing.T) {
 		t.Run(strconv.Itoa(i)+"_"+tc.name, func(t *testing.T) {
 			t.Parallel()
 
-			middleware := LogicalPlanGenMiddleware(false, 5*time.Minute)
+			middleware := DistributedQueryMiddleware(false, 5*time.Minute)
 
 			handler := middleware.Wrap(HandlerFunc(func(_ context.Context, req Request) (Response, error) {
 				return nil, nil

pkg/querier/tripperware/instantquery/instant_query_middlewares.go

@@ -25,7 +25,7 @@ func Middlewares(
 
 	if distributedExecEnabled {
 		m = append(m,
-			tripperware.LogicalPlanGenMiddleware(enablePerStepStats, lookbackDelta))
+			tripperware.DistributedQueryMiddleware(enablePerStepStats, lookbackDelta))
 	}
 
 	return m, nil

pkg/querier/tripperware/query.go

@@ -223,10 +223,10 @@ func (m *PrometheusRequest) GetStats() string {
 }
 
 func (m *PrometheusRequest) GetLogicalPlan() logicalplan.Plan {
-	if m != nil {
-		return m.LogicalPlan
+	if m == nil {
+		return nil
 	}
-	return nil
+	return m.LogicalPlan
 }
 
 // WithStartEnd clones the current `PrometheusRequest` with a new `start` and `end` timestamp.

pkg/querier/tripperware/queryrange/query_range_middlewares.go

@@ -142,7 +142,7 @@ func Middlewares(
 	if distributedExecEnabled {
 		queryRangeMiddleware = append(queryRangeMiddleware,
 			tripperware.InstrumentMiddleware("range_logical_plan_gen", metrics),
-			tripperware.LogicalPlanGenMiddleware(enablePerStepStats, lookbackDelta))
+			tripperware.DistributedQueryMiddleware(enablePerStepStats, lookbackDelta))
 	}
 
 	return queryRangeMiddleware, c, nil