Implement custom RangeQuery interface to support Elasticsearch v9 (#7358)

## Which problem is this PR solving?
- Resolves #7274 
- Resolves compatibility issues with Elasticsearch v9 caused by the
removal of deprecated fields in the `RangeQuery` structure from the
`olivere/elastic` client.
- Enables Jaeger to run with Elasticsearch v9+ by replacing the use of
`olivere/elastic/v7.RangeQuery` with a custom implementation.

## Description of the changes
- Introduced a custom `RangeQuery` interface under
`internal/storage/elasticsearch/query`.
- Removed usage of deprecated fields such as `include_lower`,
`include_upper`, `from`, and `to`.
- Replaced all internal references to the legacy `RangeQuery` with the
new implementation.
- Ensured the new query format aligns with the expected request
structure in Elasticsearch v9's `_search` API.

## How was this change tested?
- Added and ran unit tests for the custom `RangeQuery` implementation.
- Successfully built and ran Jaeger components with Elasticsearch v9
Docker image (`docker.elastic.co/elasticsearch/elasticsearch:9.0.3`).

## Checklist
- [x] I have read
https://github.com/jaegertracing/jaeger/blob/master/CONTRIBUTING_GUIDELINES.md
- [x] I have signed all commits
- [x] I have added unit tests for the new functionality
- [x] I have run lint and test steps successfully
  - for `jaeger`: `make lint test`
  - for `jaeger-ui`: `npm run lint` and `npm run test`

---------

Signed-off-by: Mohammed Shuraih <shuraih15@gmail.com>
Signed-off-by: shuraih775 <74284337+shuraih775@users.noreply.github.com>
Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com>
Co-authored-by: Yuri Shkuro <yurishkuro@users.noreply.github.com>

Author: 3 people

.github/workflows/ci-e2e-elasticsearch.yml

@@ -30,6 +30,9 @@ jobs:
         - major: 8.x
           distribution: elasticsearch
           jaeger: v2
+        - major: 9.x
+          distribution: elasticsearch
+          jaeger: v2
     name: ${{ matrix.version.distribution }} ${{ matrix.version.major }} ${{ matrix.version.jaeger }}
     steps:
     - name: Harden Runner

docker-compose/elasticsearch/v9/docker-compose.yml

@@ -0,0 +1,14 @@
+services:
+  elasticsearch:
+    image: docker.elastic.co/elasticsearch/elasticsearch:9.0.4@sha256:59da431b8987b508af17a9424f1f03398ecaacc09c4218abe306749b524f1519
+    environment:
+      - discovery.type=single-node
+      - http.host=0.0.0.0
+      - transport.host=127.0.0.1
+      - xpack.security.enabled=false  # Disable security features
+      - xpack.security.http.ssl.enabled=false  # Disable HTTPS
+      - action.destructive_requires_name=false
+      - xpack.monitoring.collection.enabled=false  # Disable monitoring features
+    ports:
+      - "9200:9200"
+      

internal/storage/elasticsearch/query/range_query.go

@@ -0,0 +1,66 @@
+// Copyright (c) 2025 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package query
+
+// Package query provides an Elasticsearch RangeQuery implementation.
+// This RangeQuery behaves the same as the Go Elasticsearch client (olivere/elastic),
+// but is rewritten to be compatible with Elasticsearch v9 and avoids deprecated parameters.
+//
+// Deprecated parameters like include_lower, include_upper, from, and to are excluded deliberately.
+
+type RangeQuery struct {
+	name      string
+	queryName string
+	params    map[string]any
+}
+
+// NewRangeQuery creates and initializes a new RangeQuery.
+func NewRangeQuery(name string) *RangeQuery {
+	return &RangeQuery{
+		name:   name,
+		params: make(map[string]any),
+	}
+}
+
+// Generic setter
+func (q *RangeQuery) set(key string, val any) *RangeQuery {
+	q.params[key] = val
+	return q
+}
+
+func (q *RangeQuery) Gt(val any) *RangeQuery      { return q.set("gt", val) }
+func (q *RangeQuery) Gte(val any) *RangeQuery     { return q.set("gte", val) }
+func (q *RangeQuery) Lt(val any) *RangeQuery      { return q.set("lt", val) }
+func (q *RangeQuery) Lte(val any) *RangeQuery     { return q.set("lte", val) }
+func (q *RangeQuery) Boost(b float64) *RangeQuery { return q.set("boost", b) }
+func (q *RangeQuery) TimeZone(tz string) *RangeQuery {
+	return q.set("time_zone", tz)
+}
+
+func (q *RangeQuery) Format(fmt string) *RangeQuery {
+	return q.set("format", fmt)
+}
+
+func (q *RangeQuery) Relation(r string) *RangeQuery {
+	return q.set("relation", r)
+}
+
+func (q *RangeQuery) QueryName(queryName string) *RangeQuery {
+	q.queryName = queryName
+	return q
+}
+
+// Source builds and returns the Elasticsearch-compatible representation of the range query.
+
+func (q *RangeQuery) Source() (any, error) {
+	source := make(map[string]any)
+	rangeQ := make(map[string]any)
+	source["range"] = rangeQ
+	rangeQ[q.name] = q.params
+
+	if q.queryName != "" {
+		rangeQ["_name"] = q.queryName
+	}
+	return source, nil
+}

internal/storage/elasticsearch/query/range_query_test.go

@@ -0,0 +1,63 @@
+// Copyright (c) 2025 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package query
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/jaegertracing/jaeger/internal/testutils"
+)
+
+func assertRangeQuery(t *testing.T, q *RangeQuery, expected string) {
+	t.Helper()
+	src, err := q.Source()
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := json.Marshal(src)
+	if err != nil {
+		t.Fatalf("marshaling to JSON failed: %v", err)
+	}
+	got := string(data)
+	if got != expected {
+		t.Errorf("expected:\n%s\ngot:\n%s", expected, got)
+	}
+}
+
+func TestRangeQuery(t *testing.T) {
+	q := NewRangeQuery("postDate").
+		Gte("2010-03-01").
+		Lte("2010-04-01").
+		Boost(3).
+		Relation("within").
+		QueryName("my_query")
+
+	expected := `{"range":{"_name":"my_query","postDate":{"boost":3,"gte":"2010-03-01","lte":"2010-04-01","relation":"within"}}}`
+	assertRangeQuery(t, q, expected)
+}
+
+func TestRangeQueryWithTimeZone(t *testing.T) {
+	q := NewRangeQuery("born").
+		Gte("2012-01-01").
+		Lte("now").
+		TimeZone("+1:00")
+
+	expected := `{"range":{"born":{"gte":"2012-01-01","lte":"now","time_zone":"+1:00"}}}`
+	assertRangeQuery(t, q, expected)
+}
+
+func TestRangeQueryWithFormat(t *testing.T) {
+	q := NewRangeQuery("born").
+		Gt("2012/01/01").
+		Lt("now").
+		Format("yyyy/MM/dd")
+
+	expected := `{"range":{"born":{"format":"yyyy/MM/dd","gt":"2012/01/01","lt":"now"}}}`
+	assertRangeQuery(t, q, expected)
+}
+
+func TestMain(m *testing.M) {
+	testutils.VerifyGoLeaks(m)
+}

internal/storage/metricstore/elasticsearch/query_builder.go

@@ -15,6 +15,7 @@ import (
 	"github.com/jaegertracing/jaeger-idl/model/v1"
 	es "github.com/jaegertracing/jaeger/internal/storage/elasticsearch"
 	"github.com/jaegertracing/jaeger/internal/storage/elasticsearch/config"
+	esquery "github.com/jaegertracing/jaeger/internal/storage/elasticsearch/query"
 	"github.com/jaegertracing/jaeger/internal/storage/v1/api/metricstore"
 	"github.com/jaegertracing/jaeger/internal/storage/v1/elasticsearch/spanstore"
 )
@@ -70,7 +71,7 @@ func (q *QueryBuilder) BuildBoolQuery(params metricstore.BaseQueryParameters, ti
 		boolQuery.Filter(termQuery)
 	}
 
-	rangeQuery := elastic.NewRangeQuery("startTimeMillis").
+	rangeQuery := esquery.NewRangeQuery("startTimeMillis").
 		Gte(timeRange.extendedStartTimeMillis).
 		Lte(timeRange.endTimeMillis).
 		Format("epoch_millis")

internal/storage/v1/elasticsearch/samplingstore/storage.go

@@ -15,6 +15,7 @@ import (
 
 	es "github.com/jaegertracing/jaeger/internal/storage/elasticsearch"
 	"github.com/jaegertracing/jaeger/internal/storage/elasticsearch/config"
+	esquery "github.com/jaegertracing/jaeger/internal/storage/elasticsearch/query"
 	"github.com/jaegertracing/jaeger/internal/storage/v1/api/samplingstore/model"
 	"github.com/jaegertracing/jaeger/internal/storage/v1/elasticsearch/samplingstore/dbmodel"
 )
@@ -190,7 +191,7 @@ func (p *Params) PrefixedIndexName() string {
 }
 
 func buildTSQuery(start, end time.Time) elastic.Query {
-	return elastic.NewRangeQuery("timestamp").Gte(start).Lte(end)
+	return esquery.NewRangeQuery("timestamp").Gte(start).Lte(end)
 }
 
 func indexWithDate(indexNamePrefix, indexDateLayout string, date time.Time) string {

internal/storage/v1/elasticsearch/spanstore/reader.go

@@ -24,6 +24,7 @@ import (
 	es "github.com/jaegertracing/jaeger/internal/storage/elasticsearch"
 	cfg "github.com/jaegertracing/jaeger/internal/storage/elasticsearch/config"
 	"github.com/jaegertracing/jaeger/internal/storage/elasticsearch/dbmodel"
+	esquery "github.com/jaegertracing/jaeger/internal/storage/elasticsearch/query"
 )
 
 const (
@@ -635,7 +636,7 @@ func (*SpanReader) buildDurationQuery(durationMin time.Duration, durationMax tim
 	if durationMax != 0 {
 		maxDurationMicros = model.DurationAsMicroseconds(durationMax)
 	}
-	return elastic.NewRangeQuery(durationField).Gte(minDurationMicros).Lte(maxDurationMicros)
+	return esquery.NewRangeQuery(durationField).Gte(minDurationMicros).Lte(maxDurationMicros)
 }
 
 func (*SpanReader) buildStartTimeQuery(startTimeMin time.Time, startTimeMax time.Time) elastic.Query {
@@ -644,7 +645,7 @@ func (*SpanReader) buildStartTimeQuery(startTimeMin time.Time, startTimeMax time
 	// startTimeMillisField is date field in ES mapping.
 	// Using date field in range queries helps to skip search on unnecessary shards at Elasticsearch side.
 	// https://discuss.elastic.co/t/timeline-query-on-timestamped-indices/129328/2
-	return elastic.NewRangeQuery(startTimeMillisField).Gte(minStartTimeMicros / 1000).Lte(maxStartTimeMicros / 1000)
+	return esquery.NewRangeQuery(startTimeMillisField).Gte(minStartTimeMicros / 1000).Lte(maxStartTimeMicros / 1000)
 }
 
 func (*SpanReader) buildServiceNameQuery(serviceName string) elastic.Query {

internal/storage/v1/elasticsearch/spanstore/reader_test.go

@@ -1093,10 +1093,9 @@ func TestSpanReader_buildFindTraceIDsQuery(t *testing.T) {
 
 func TestSpanReader_buildDurationQuery(t *testing.T) {
 	expectedStr := `{ "range":
-			{ "duration": { "include_lower": true,
-				        "include_upper": true,
-				        "from": 1000000,
-				        "to": 2000000 }
+			{ "duration": {
+				        "gte": 1000000,
+				        "lte": 2000000 }
 			}
 		}`
 	withSpanReader(t, func(r *spanReaderTest) {
@@ -1109,19 +1108,18 @@ func TestSpanReader_buildDurationQuery(t *testing.T) {
 		expected := make(map[string]any)
 		json.Unmarshal([]byte(expectedStr), &expected)
 		// We need to do this because we cannot process a json into uint64.
-		expected["range"].(map[string]any)["duration"].(map[string]any)["from"] = model.DurationAsMicroseconds(durationMin)
-		expected["range"].(map[string]any)["duration"].(map[string]any)["to"] = model.DurationAsMicroseconds(durationMax)
+		expected["range"].(map[string]any)["duration"].(map[string]any)["gte"] = model.DurationAsMicroseconds(durationMin)
+		expected["range"].(map[string]any)["duration"].(map[string]any)["lte"] = model.DurationAsMicroseconds(durationMax)
 
 		assert.EqualValues(t, expected, actual)
 	})
 }
 
 func TestSpanReader_buildStartTimeQuery(t *testing.T) {
 	expectedStr := `{ "range":
-			{ "startTimeMillis": { "include_lower": true,
-				         "include_upper": true,
-				         "from": 1000000,
-				         "to": 2000000 }
+			{ "startTimeMillis": {
+				         "gte": 1000000,
+				         "lte": 2000000 }
 			}
 		}`
 	withSpanReader(t, func(r *spanReaderTest) {
@@ -1134,8 +1132,8 @@ func TestSpanReader_buildStartTimeQuery(t *testing.T) {
 		expected := make(map[string]any)
 		json.Unmarshal([]byte(expectedStr), &expected)
 		// We need to do this because we cannot process a json into uint64.
-		expected["range"].(map[string]any)["startTimeMillis"].(map[string]any)["from"] = model.TimeAsEpochMicroseconds(startTimeMin) / 1000
-		expected["range"].(map[string]any)["startTimeMillis"].(map[string]any)["to"] = model.TimeAsEpochMicroseconds(startTimeMax) / 1000
+		expected["range"].(map[string]any)["startTimeMillis"].(map[string]any)["gte"] = model.TimeAsEpochMicroseconds(startTimeMin) / 1000
+		expected["range"].(map[string]any)["startTimeMillis"].(map[string]any)["lte"] = model.TimeAsEpochMicroseconds(startTimeMax) / 1000
 
 		assert.EqualValues(t, expected, actual)
 	})

internal/storage/v2/elasticsearch/depstore/storage.go

@@ -16,6 +16,7 @@ import (
 
 	es "github.com/jaegertracing/jaeger/internal/storage/elasticsearch"
 	"github.com/jaegertracing/jaeger/internal/storage/elasticsearch/config"
+	esquery "github.com/jaegertracing/jaeger/internal/storage/elasticsearch/query"
 	"github.com/jaegertracing/jaeger/internal/storage/v2/elasticsearch/depstore/dbmodel"
 )
 
@@ -116,7 +117,7 @@ func (s *DependencyStore) GetDependencies(ctx context.Context, endTs time.Time,
 }
 
 func buildTSQuery(endTs time.Time, lookback time.Duration) elastic.Query {
-	return elastic.NewRangeQuery("timestamp").Gte(endTs.Add(-lookback)).Lte(endTs)
+	return esquery.NewRangeQuery("timestamp").Gte(endTs.Add(-lookback)).Lte(endTs)
 }
 
 func (s *DependencyStore) getReadIndices(ts time.Time, lookback time.Duration) []string {