chore: add stream count and result information to metrics.go (#20055)

Author: slim-bean

pkg/logql/metrics.go

@@ -12,6 +12,8 @@ import (
 	"github.com/go-kit/log/level"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
+	"github.com/prometheus/prometheus/model/labels"
+	"github.com/prometheus/prometheus/promql"
 	promql_parser "github.com/prometheus/prometheus/promql/parser"
 
 	"github.com/grafana/loki/v3/pkg/analytics"
@@ -42,6 +44,24 @@ const (
 	slowQueryThresholdSecond = float64(10)
 )
 
+type componentCtxKey string
+
+const (
+	componentKey      componentCtxKey = "logql_component"
+	componentFrontend string          = "frontend"
+)
+
+// WithComponentContext adds a component identifier to the context
+func WithComponentContext(ctx context.Context, component string) context.Context {
+	return context.WithValue(ctx, componentKey, component)
+}
+
+// isFrontendContext checks if the context indicates this is being logged from the frontend
+func isFrontendContext(ctx context.Context) bool {
+	component, _ := ctx.Value(componentKey).(string)
+	return component == componentFrontend
+}
+
 var (
 	bytesPerSecond = promauto.NewHistogramVec(prometheus.HistogramOpts{
 		Namespace: constants.Loki,
@@ -237,6 +257,31 @@ func RecordRangeAndInstantQueryMetrics(
 		logValues = append(logValues, "has_labelfilter_before_parser", "false")
 	}
 
+	// Add querier-specific metrics: total stream count
+	// This is only logged from the querier component, not from the frontend
+	// (where stats are merged and this value would be inaccurate)
+	if !isFrontendContext(ctx) && stats.Index.TotalStreams > 0 {
+		logValues = append(logValues, "total_stream_count", stats.Index.TotalStreams)
+	}
+
+	// Add frontend-specific metrics: approximate result size, streams count, lines count
+	// These are available when logging from the frontend component
+	if result != nil {
+		resultSize := calculateResultSize(result)
+		if resultSize > 0 {
+			// approx_result_size is an estimate of the result size in bytes (without serialization)
+			logValues = append(logValues, "approx_result_size", util.HumanizeBytes(uint64(resultSize)))
+		}
+
+		// Extract stream and line counts for log queries
+		if streams, ok := result.(logqlmodel.Streams); ok {
+			logValues = append(logValues,
+				"result_streams_count", len(streams),
+				"result_lines_count", streams.Lines(),
+			)
+		}
+	}
+
 	level.Info(logger).Log(
 		logValues...,
 	)
@@ -581,6 +626,75 @@ func extractShard(shards []string) *astmapper.ShardAnnotation {
 	return &shard
 }
 
+// calculateResultSize calculates an approximate estimate of the result size in bytes
+// without serialization by summing up the actual data sizes plus estimated JSON overhead.
+// This is an approximation and may not match the exact serialized size. Used for frontend logging.
+func calculateResultSize(result promql_parser.Value) int {
+	if result == nil {
+		return 0
+	}
+
+	switch v := result.(type) {
+	case logqlmodel.Streams:
+		var size int
+		for _, stream := range v {
+			size += len(stream.Labels) // Stream labels
+			size += 20
+			for _, entry := range stream.Entries {
+				size += len(entry.Line) // Entry line content
+				size += 20              // Timestamp as string (~20 bytes for RFC3339Nano)
+				size += 10              // JSON overhead for entry array (~10 bytes: ["timestamp","line"])
+				for _, label := range entry.StructuredMetadata {
+					size += len(label.Name) + len(label.Value) + 10 // +10 for JSON overhead
+				}
+				for _, label := range entry.Parsed {
+					size += len(label.Name) + len(label.Value) + 10 // +10 for JSON overhead
+				}
+			}
+		}
+		size += 2 // Account for [] brackets
+		return size
+	case promql.Vector:
+		var size int
+		for _, sample := range v {
+			size += estimateLabelsSize(sample.Metric) // Metric labels
+			size += 30                                // Value array: [timestamp, value] (~30 bytes)
+			size += 15                                // JSON object overhead (~15 bytes)
+		}
+		size += 2 // Account for [] brackets
+		return size
+	case promql.Matrix:
+		var size int
+		for _, series := range v {
+			size += estimateLabelsSize(series.Metric) // Metric labels
+			size += 10                                // Values array overhead
+			size += len(series.Floats) * 20           // Each data point (~20 bytes: [timestamp, value])
+			size += 15                                // JSON object overhead (~15 bytes)
+		}
+		size += 2 // Account for [] brackets
+		return size
+	case promql.Scalar:
+		return 30 // Scalar: [timestamp, value] (~30 bytes)
+	case promql.String:
+		return 20 + len(v.V) // String: [timestamp, value] (~20 bytes + string length)
+	default:
+		return 0 // For unknown types, return 0
+	}
+}
+
+// estimateLabelsSize estimates the JSON size of labels
+func estimateLabelsSize(lbs labels.Labels) int {
+	if lbs.Len() == 0 {
+		return 2 // Account for {} brackets
+	}
+	var size int
+	size += 2 // Account for {} brackets
+	lbs.Range(func(label labels.Label) {
+		size += len(label.Name) + len(label.Value) + 5 // "name":"value",
+	})
+	return size
+}
+
 func RecordDetectedLabelsQueryMetrics(ctx context.Context, log log.Logger, start time.Time, end time.Time, query string, status string, stats logql_stats.Result) {
 	var (
 		logger      = fixLogger(ctx, log)

pkg/querier/queryrange/stats.go

@@ -52,6 +52,8 @@ var (
 // recordQueryMetrics will be called from Query Frontend middleware chain for any type of query.
 func recordQueryMetrics(data *queryData) {
 	logger := log.With(util_log.Logger, "component", "frontend")
+	// Mark context as frontend so metrics logging can distinguish between frontend and querier
+	data.ctx = logql.WithComponentContext(data.ctx, "frontend")
 
 	switch data.queryType {
 	case queryTypeLog, queryTypeMetric: