Repository: jaegertracing/jaeger

Issue:
Remove dead code
### Requirement

Remove dead code from the repository

### Proposal

Use official `deadcode` tool to identify unused code https://mfbmina.dev/en/posts/golang-deadcode/. It currently lists quite a few functions and packages.

### Recommended process

1. Run deadcode tool and pick ONE package to focus on.
2. Post a comment to this issue stating which package you're working on
3. Do not just delete the package / function, do some research first
   * find where (which PR) the function was introduced and what was using it & why
   * ideally find the PR in which that usage was removed without removing the function itself
   * post your findings in the comments to validate with maintainers that it's ok to delete


Discussion:
@nomic-embed: Hi @yurishkuro,

i have started with identification of unreachable functions with deadcode.
i am working on **cmd/ingester/** module and found out some deadcode but facing issues in pin pointing the related commit and PR.

Any help will be greatly appreciated.

Thanks!! @yurishkuro: You can use git blame to show commits for specific lines, or git log to show history of the whole file. Sometimes files get moved so you may need to follow those moves. Once you have an interesting commit use git show to see more details and the pr number usually will be in the commit message. @nomic-embed: Thanks,

Sure, I will leverage the information for further investigation.@AnmolxSingh: Hi @yurishkuro 
I have been examining the `examples` package and found a function that is not in use https://github.com/jaegertracing/jaeger/blob/cc7ea8d7fd5403c78e0a23db5c6bf06188c32546/examples/hotrod/pkg/pool/pool.go#L41

It was in introduced in pr [#40](https://github.com/jaegertracing/jaeger/pull/40)
and was latest updated in pr [#1454](https://github.com/jaegertracing/jaeger/pull/1454)

I am not able to find or get a clear indication where in the current codebase it was being used.
@yurishkuro: @AnmolxSingh this is because HotROD does not implement proper shutdown sequence, which should be invoked when the program receives a kill signal (other Jaeger binaries do trap the signal and perform shutdown)@AnmolxSingh: Hi @yurishkuro 
while examining the `internal` package I found a function which might be a example of dead code.
https://github.com/jaegertracing/jaeger/blob/f887e133cce1ffcbb4015868025f6bfd4c035764/internal/testutils/logger.go#L90

Just wanted to know is here to serve some purpose?
Introduced in pr [#198](https://github.com/jaegertracing/jaeger/pull/198)@yurishkuro: @AnmolxSingh I'd expect this function to be required by the API in the logging library. It doesn't mean our code would be invoking it directly. How else would the data be written to the buffer by the logging library?

@AnmolxSingh: Hi @yurishkuro,

While examining the codebase, I found that most of the functions identified as unused (dead code) are either:

- Used in `*_test.go` files, or
- Auto-generated by `thrift-0.9.2`.

Aside from those cases and the functions we've already discussed, I didn’t find any other obvious unused functions.

Please let me know if I am missing something.

Thanks!
@blazethunderstorm: hi @yurishkuro can i work on the cmd/collector/app/sanitizer module and investigating the function NewServiceNameSanitizer, which was reported as unreachable.@vtripathi04: Hello @yurishkuro, I am new to this project and thought this is a good issue to start with.

I ran the deadcode tool as suggested and found the file `cmd\query\app\querysvc\query_service_test.go` has dead code in it. 

The functions that are identified as deadcode by the tool are: 

```
unreachable func: fakeStorageFactory1.Initialize
unreachable func: fakeStorageFactory1.CreateSpanReader
unreachable func: fakeStorageFactory1.CreateSpanWriter
unreachable func: fakeStorageFactory1.CreateDependencyReader
```

Upon investigating further I found out all of these functions were introduced in PR  [#1503 ](https://github.com/jaegertracing/jaeger/pull/1503#ref-pullrequest-436336737) , [here](https://github.com/jaegertracing/jaeger/pull/1503/commits/222851654e69566dfce26506866e3150ac364b66#diff-8f0bb159e943f0e3d69c11c0f8a6f9d7ac80d647fba0ed66b7132587a3664d93R264)

and the last PR i could find where major changes were made to this file is #6567, [here](https://github.com/jaegertracing/jaeger/commit/d7ab0f8c175956c1d36bbc2e18b34469f568e205#diff-8f0bb159e943f0e3d69c11c0f8a6f9d7ac80d647fba0ed66b7132587a3664d93R452)

Although I am not sure at what point these functions were used, It seems to me that `fakeStorageFactory1 `and its functions were likely introduced as part of early test scaffolding but were never integrated into actual test logic. Please correct me if I am wrong.

Please let me know if it is safe to remove these functions, and if I can open a PR regarding the same.

Thank you.


@yurishkuro: @AnmolxSingh we can still clean them up from test, but based on your and other comments I have a suspicion that the deadcode tool may incorrectly flag functions that exist because a struct implements a certain interface. Or are those functions truly unnecessary?@blazethunderstorm: @yurishkuro can i work on the one i asked for ?@yurishkuro: @blazethunderstorm you did not provide the analysis asked in the description@blazethunderstorm: @yurishkuro would proivde complete description in a time @AnmolxSingh: @yurishkuro

Apologies if my earlier message was unclear. What I meant was:

- The `deadcode` tool does not analyze `*_test.go` files across packages , so it flags functions as unused even though they are used (it only analyze files reachable from `main.go`).
- Similarly, it seems to flag methods that are required to satisfy interfaces as discussed earlier in previous conversation.
- Having said that, functions marked by it as deadcode are truly necessary as discussed above.

References from documentation:

![Image](https://github.com/user-attachments/assets/2de7db05-008f-41f4-b83b-30646fe23661)

![Image](https://github.com/user-attachments/assets/23e2c688-d65c-44a1-bf19-d8ff1b280cc0)

https://pkg.go.dev/golang.org/x/tools/internal/cmd/deadcode
https://go.dev/blog/deadcode

From what I’ve observed, `deadcode` mainly checks for direct callability (similar to what IDEs trace with “Ctrl+Click” navigation).

If the community is open to it, we might explore more tools which might be a better option.
Thanks!
@yurishkuro: > so it flags functions as unused even though they are used (it only analyze files reachable from main.go)

I wouldn't say this is wrong. There's no point in testing some functions if they are never used in the actual binaries.

> it seems to flag methods that are required to satisfy interfaces as discussed earlier in previous conversation.

that is definitely a problem & doesn't make any sense as a behavior of a tool with this purpose. Is it confirmed somewhere, like a bug report about this "official" tool?

Did you find any other similar tools?@AnmolxSingh: > that is definitely a problem & doesn't make any sense as a behavior of a tool with this purpose. Is it confirmed somewhere, like a bug report about this "official" tool?

actually I did not find report about this thing but the documentation gives some sort of indication for this behavior as attached in the previous comment. 
"_For example, a dead function may be referenced by another dead function, and a dead method may be required to satisfy an interface that is never called. Some judgement is required._" 

I haven't tried other tools but I feel `staticcheck` might be a possible option.

And reading about this tool it is not an official tool by the go team and now not much useful compared to other tools like
`staticcheck`@wololowarrior: `staticheck` doesn't seem to be flagging any deadcode.

```
U1000 Unused code
harshil.gupta@harshil jaeger % staticcheck -checks U1000 ./... 
```@yurishkuro: I don't know how accurate it is but AI says that staticcheck's deadcode detection doesn't work for exported functions that may be used in other packages

> Whole-program analysis limitations: In previous versions, Staticcheck had a "whole-program mode" (--unused.whole-program=true) which aimed to find unused exported identifiers even across a large program. However, this mode was removed in Staticcheck 2020.2 due to issues with caching and flakiness. Currently, Staticcheck's primary dead code detection (U1000) will consider all exported package-level identifiers as used, even if they are otherwise unused in the immediate package. This means it might not catch dead exported functions or types that are part of a library but are never imported or called by any consumers of that library. For finding true "whole-program" dead code (across multiple packages in a large monorepo, for example), you might need complementary tools or approaches.@Parship999: ## Working on: `cmd/collector/app/sanitizer/cache/` package
- when introduced: PR #67 
  - The cache package implemented a auto-refreshing cache system for service names:
    - `ServiceAliasMappingExternalSource` - load mappings from external sources
    - `ServiceAliasMappingStorage` - mappings to storage
    - `autoRefreshCache` - auto-refresh from both sources with intervals
    - used by `NewServiceNameSanitizer()` to map service aliases to canonical names

- When usage was removed: PR #3631 
  - added `NewEmptyServiceNameSanitizer()` as replacement
  - Created `NewStandardSanitizers()` function that excluded the cache-based sanitizer and alsso the cache-based `NewServiceNameSanitizer()` was never included in standard sanitizers

- I have not found any production usage:
  - `NewServiceNameSanitizer()` only used in test files (`service_name_sanitizer_test.go`)
  - Current `NewStandardSanitizers()` only includes:
    - `NewEmptyServiceNameSanitizer()` (simple, no cache)
    - `NewNegativeDurationSanitizer()` (simple, no cache)

Files that can be removed safely:
`cmd/collector/app/sanitizer/cache/` (entire directory)
`cmd/collector/app/sanitizer/service_name_sanitizer.go`
`cmd/collector/app/sanitizer/service_name_sanitizer_test.go`

This seems to be replaced by the solution in PR #3631 but the original implementation was not cleaned up. 

@yurishkuro 
I have used deadcode and also tried staticcheck but i saw that `.golangci.yml` has `staticcheck` in the disable list. Even when enabled still didn't detect the unused cache functions. 
I verified this is not a false positive. The cache package defines its own cache interface that's completely separate from the actively used `internal/cache.Cache` interface@yurishkuro: @Parship999 I don't see any mentioning of sanitizer/cache in #3631, if the usage was remove there some import or calls to NewAutoRefreshCache would've been removed@Parship999: > [@Parship999](https://github.com/Parship999) I don't see any mentioning of sanitizer/cache in [#3631](https://github.com/jaegertracing/jaeger/pull/3631), if the usage was remove there some import or calls to NewAutoRefreshCache would've been removed

Sorry, i made a mistake.
actually, the cache package is never used in production at all. Git history shows: PR #67 added the cache infrastructure (`NewAutoRefreshCache()`, `NewServiceNameSanitizer()`) but never used in prod. So no commits ever removed the usage, as there was no uage to remove. PR #3631 added `NewStandardSanitizers()`, but this actually the new functionality, not replacing cache usage. I think it may be unused since day one. The removal is still safe but the past context i provided is incorrect.
Can you please verify it?@yurishkuro: ok that makes sense. IIRC this was a function that was invoked in Uber's custom build of the binary - it didn't need to be open sourced. Feel free to remove.@wololowarrior: @yurishkuro Working on [internal/converter/thrift/jaeger/from_domain.go](https://github.com/jaegertracing/jaeger/blob/main/internal/converter/thrift/jaeger/from_domain.go), it appears that only the test file `from_domain_test.go` is utilizing it.  I can't find any real usage of the file. 
It was added as part of https://github.com/jaegertracing/jaeger/pull/65. 
Tracing is becoming sweaty for me as the pr is from 8 years ago. @yurishkuro Pls take a look while I trace its first usage@Parship999: @yurishkuro 
### Working on `cmd/all-in-one/setupcontext` package

- Package: `cmd/all-in-one/setupcontext`
  - Total functions: 3 (`SetAllInOne`, `UnsetAllInOne`, `IsAllInOne`)
  - aead functions: 2 (`UnsetAllInOne`, `IsAllInOne`)
  - active functions: 1 (`SetAllInOne`)

- current usage:
  - `SetAllInOne()`: used in `cmd/all-in-one/main.go` line 50
  - `UnsetAllInOne()`, `IsAllInOne()`: only used in test file for code coverage

- Introduced: PR #1854
- usage removed: #6868 as part of issue #4739
- Deadcode confuimation:
<img width="591" height="36" alt="Image" src="https://github.com/user-attachments/assets/413ab64e-f508-48a8-9a05-58d030e8e66e" />

- files to modify are `cmd/all-in-one/setupcontext/setupcontext.go`, `cmd/all-in-one/setupcontext/setupcontext_test.go`@yurishkuro: @Parship999 +1. IsAllInOne was only used for agent tags, and we don't have that anymore.@Parship999: > [@Parship999](https://github.com/Parship999) +1. IsAllInOne was only used for agent tags, and we don't have that anymore.

Thanks for confirming. Should I go ahead and remove it?@yurishkuro: that's what +1 was for :-)@wololowarrior: > [@yurishkuro](https://github.com/yurishkuro) Working on [internal/converter/thrift/jaeger/from_domain.go](https://github.com/jaegertracing/jaeger/blob/main/internal/converter/thrift/jaeger/from_domain.go), it appears that only the test file `from_domain_test.go` is utilizing it. I can't find any real usage of the file. It was added as part of [#65](https://github.com/jaegertracing/jaeger/pull/65). Tracing is becoming sweaty for me as the pr is from 8 years ago. [@yurishkuro](https://github.com/yurishkuro) Pls take a look while I trace its first usage

@yurishkuro updates

Some background info first:
- `/model/` was moved to `/internal/` in [this](https://github.com/jaegertracing/jaeger/pull/6917/files#diff-ff098a2fa68c02a5d7084d463fc2916787066cbec047139e28d505577bf655b8) pr
- This info is important cause the below references are using `/model/` but then it was moved to `internal`

Added:
The only place I could find the use of  methods from `from_domain.go` is [here](https://github.com/jaegertracing/jaeger/pull/862/files#diff-f24753e235d3fb6d0b2264d42c52c1455bbdd4a9e75dfd4a410d88840aa12578R41)
- Uses `FromDomainSpan`


Removed:
From the [pr](https://github.com/jaegertracing/jaeger/pull/868/files#diff-f24753e235d3fb6d0b2264d42c52c1455bbdd4a9e75dfd4a410d88840aa12578R39) removing usage of `FromDomainSpan`. 
```
Thrift model doesn't have the process in the definition, therefore encoding causes loss of data when writing
```

Summary on:
`from_domain.go`
- Has 7 methods, of which 
  - All 7 of them are not used anywhere else in business logic.
  - `FromDomain`, `FromDomainSpan`, `keyValueToTag` are used in `from_domain_test.go`@Parship999: ### Working on: `cmd/collector/app/sanitizer/utf8_sanitizer.go`
- When introduced: PR #67
- When replaced: PR #6078 (New UTF8 sanitizer implemented for OTLP/ptrace data (`ptrace.Traces`), located at  `internal/jptrace/sanitizer/utf8.go`)
- Current state: two different UTF8 sanitizers exist:
  - Old and unused (`cmd/collector/app/sanitizer/utf8_sanitizer.go`)
  - New and used (`internal/jptrace/sanitizer/utf8.go`)
- I have not found any prod usage:
  - old UTF8 sanitizer only used in its own test file (`utf8_sanitizer_test.go`)
  - the new OTLP-based UTF8 sanitizer handles all UTF8 sanitization needs
- Files to remove safely:
   - `cmd/collector/app/sanitizer/utf8_sanitizer.go`
   - `cmd/collector/app/sanitizer/utf8_sanitizer_test.go`

@yurishkuro can you please confirm this analysis is correct or not?@Parship999: @yurishkuro 
### Working on: `cmd/collector/app/sanitizer/service_name_sanitizer.go`
- When introduced: PR #67
- when replaced:
  - First Replacement - PR #3631
  - modern OTLP implementation - PR #6077
  - final location - PR #7158
- Current State:
  - Old-dead `cmd/collector/app/sanitizer/service_name_sanitizer.go`
  - Legacy-used `cmd/collector/app/sanitizer/empty_service_name_sanitizer.go`
  - Modern-used `internal/jptrace/sanitizer/emptyservicename.go`
- No prod usage
- Files to remove:
  - `cmd/collector/app/sanitizer/service_name_sanitizer.go`
  - `cmd/collector/app/sanitizer/service_name_sanitizer_test.go`@yurishkuro: @Parship999 delete it, it was closely coupled with Cache@wololowarrior: @yurishkuro Does https://github.com/jaegertracing/jaeger/issues/7261#issuecomment-3101299309 makes sense ? Should I go ahead with a PR? @yurishkuro: @wololowarrior yes@Parship999: @yurishkuro 
### Working on: `examples/hotrod/pkg/pool/pool.go` (`Pool.Stop` Method)
- Files identified by deadcode tool: `examples/hotrod/pkg/pool/pool.go`: - `Pool.Stop` method unreachable
- When introduced: PR #40
- When fixed: PR #1454
- current state: `Pool.Stop()` method is never called anywhere in the codebase. Only `Pool.New()` and `Pool.Execute()` are used in production
- Files to modify: `examples/hotrod/pkg/pool/pool.go` - remove `Stop()` method (lines 40-45)@Parship999: @yurishkuro 
### Working on:  `internal/jptrace/utf8.go`
- Files identified by deadcode tool: `internal/jptrace/utf8.go` - `SanitizeUTF8` function unreachable
- When introduced: PR #7128
- When unused: the pr that introduced it never actually used the function
- The fix was implemented by switching from `WithLabelValues()` to `GetMetricWithLabelValues()` in the prometheus factory, the `SanitizeUTF8` function was added but never used.
- Files to remove:
  - `internal/jptrace/utf8.go`
  - `internal/jptrace/utf8_test.go`@Parship999: > [@yurishkuro](https://github.com/yurishkuro)
> 
> ### Working on: `examples/hotrod/pkg/pool/pool.go` (`Pool.Stop` Method)
> * Files identified by deadcode tool: `examples/hotrod/pkg/pool/pool.go`: - `Pool.Stop` method unreachable
> * When introduced: PR [Add demo tracing app #40](https://github.com/jaegertracing/jaeger/pull/40)
> * When fixed: PR [Fix HotRod job pool termination (#1453) #1454](https://github.com/jaegertracing/jaeger/pull/1454)
> * current state: `Pool.Stop()` method is never called anywhere in the codebase. Only `Pool.New()` and `Pool.Execute()` are used in production
> * Files to modify: `examples/hotrod/pkg/pool/pool.go` - remove `Stop()` method (lines 40-45)

@yurishkuro can you please verify this one? `Pool.Stop()`

Solution patch:
diff --git a/.github/workflows/ci-e2e-elasticsearch.yml b/.github/workflows/ci-e2e-elasticsearch.yml
index c0b98103..7d2a3a00 100644
--- a/.github/workflows/ci-e2e-elasticsearch.yml
+++ b/.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
diff --git a/cmd/all-in-one/main.go b/cmd/all-in-one/main.go
index a70ba3d6..ecb52b44 100644
--- a/cmd/all-in-one/main.go
+++ b/cmd/all-in-one/main.go
@@ -18,7 +18,6 @@ import (
 	_ "go.uber.org/automaxprocs"
 	"go.uber.org/zap"
 
-	"github.com/jaegertracing/jaeger/cmd/all-in-one/setupcontext"
 	collectorApp "github.com/jaegertracing/jaeger/cmd/collector/app"
 	collectorFlags "github.com/jaegertracing/jaeger/cmd/collector/app/flags"
 	"github.com/jaegertracing/jaeger/cmd/internal/docs"
@@ -47,7 +46,6 @@ import (
 // all-in-one/main is a standalone full-stack jaeger backend, backed by a memory store
 func main() {
 	flags.PrintV1EOL()
-	setupcontext.SetAllInOne()
 
 	svc := flags.NewService(ports.CollectorAdminHTTP)
 
diff --git a/cmd/all-in-one/setupcontext/setupcontext.go b/cmd/all-in-one/setupcontext/setupcontext.go
deleted file mode 100644
index 396c1bd2..00000000
--- a/cmd/all-in-one/setupcontext/setupcontext.go
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright (c) 2019 The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package setupcontext
-
-var isAllInOne bool
-
-// SetAllInOne sets the internal flag to all in one on.
-func SetAllInOne() {
-	isAllInOne = true
-}
-
-// UnsetAllInOne unsets the internal all-in-one flag.
-func UnsetAllInOne() {
-	isAllInOne = false
-}
-
-// IsAllInOne returns true when all in one mode is on.
-func IsAllInOne() bool {
-	return isAllInOne
-}
diff --git a/docker-compose/elasticsearch/v9/docker-compose.yml b/docker-compose/elasticsearch/v9/docker-compose.yml
new file mode 100644
index 00000000..ed2e295c
--- /dev/null
+++ b/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"
+      
diff --git a/examples/oci/jaeger-values.yaml b/examples/oci/jaeger-values.yaml
index 49921917..8d8e8726 100644
--- a/examples/oci/jaeger-values.yaml
+++ b/examples/oci/jaeger-values.yaml
@@ -7,6 +7,10 @@ hotrod:
   extraArgs:
     - --otel-exporter=otlp
     - --basepath=/hotrod
+  livenessProbe:
+    path: /hotrod
+  readinessProbe: 
+    path: /hotrod
   extraEnv:
     - name: OTEL_EXPORTER_OTLP_ENDPOINT
       value: http://jaeger-collector:4318
diff --git a/examples/oci/monitoring-values.yaml b/examples/oci/monitoring-values.yaml
index 7efb93e2..f95b28ac 100644
--- a/examples/oci/monitoring-values.yaml
+++ b/examples/oci/monitoring-values.yaml
@@ -15,5 +15,5 @@ grafana:
   grafana.ini:
     server:
       domain: demo.jaegertracing.io
-      root_url: "%(protocol)s://%(domain)s:%(http_port)s/grafana/"
+      root_url: "%(protocol)s://%(domain)s/grafana/"
       serve_from_sub_path: true
\ No newline at end of file
diff --git a/internal/auth/tokenloader.go b/internal/auth/tokenloader.go
new file mode 100644
index 00000000..8d6e2ae2
--- /dev/null
+++ b/internal/auth/tokenloader.go
@@ -0,0 +1,77 @@
+// Copyright (c) 2025 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package auth
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"go.uber.org/zap"
+)
+
+// CachedFileTokenLoader returns a function that loads a token from the given file path,
+// caches it for the specified interval, and reloads after the interval expires.
+// disable Reloading by setting interval to 0
+func cachedFileTokenLoader(path string, interval time.Duration, timeFn func() time.Time) func() (string, error) {
+	var (
+		mu          sync.Mutex
+		cachedToken string
+		lastRead    time.Time
+	)
+
+	return func() (string, error) {
+		mu.Lock()
+		defer mu.Unlock()
+
+		now := timeFn()
+
+		// Special case: interval = 0 means "never reload after first load"
+		// Otherwise reload only if `interval` time has passed since last load.
+		if !lastRead.IsZero() && (interval == 0 || now.Sub(lastRead) < interval) {
+			return cachedToken, nil
+		}
+
+		// Read from file
+		b, err := os.ReadFile(filepath.Clean(path))
+		if err != nil {
+			return "", fmt.Errorf("failed to read token file: %w", err)
+		}
+
+		cachedToken = strings.TrimRight(string(b), "\r\n")
+		lastRead = now
+		return cachedToken, nil
+	}
+}
+
+// TokenProvider creates a token provider that handles file loading and error handling consistently.
+func TokenProvider(path string, interval time.Duration, logger *zap.Logger) (func() string, error) {
+	return TokenProviderWithTime(path, interval, logger, time.Now) // Use real time.Now in production
+}
+
+// TokenProviderWithTime creates a token provider with injectable time (for testing)
+func TokenProviderWithTime(path string, interval time.Duration, logger *zap.Logger, timeFn func() time.Time) (func() string, error) {
+	loader := cachedFileTokenLoader(path, interval, timeFn)
+
+	// current token load
+	currentToken, err := loader()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get token from file: %w", err)
+	}
+
+	return func() string {
+		newToken, err := loader()
+		if err != nil {
+			logger.Warn("Token reload failed", zap.Error(err))
+			return currentToken
+		}
+
+		// save it in case the load fails later (e.g. if file is removed)
+		currentToken = newToken
+		return currentToken
+	}, nil
+}
diff --git a/internal/auth/transport.go b/internal/auth/transport.go
index 76a1ae35..6ff12c38 100644
--- a/internal/auth/transport.go
+++ b/internal/auth/transport.go
@@ -4,23 +4,30 @@
 package auth
 
 import (
+	"context"
 	"errors"
+	"fmt"
 	"net/http"
-
-	"github.com/jaegertracing/jaeger/internal/auth/bearertoken"
 )
 
+// Method represents a single authentication method configuration
+type Method struct {
+	// Scheme is the authentication scheme (e.g., "Bearer")
+	Scheme string
+
+	// TokenFn returns the authentication token
+	TokenFn func() string
+
+	// FromCtx extracts token from context
+	FromCtx func(context.Context) (string, bool)
+}
+
 // RoundTripper wraps another http.RoundTripper and injects
-// an authentication header with bearer token into requests.
+// an authentication header with  token into requests.
 type RoundTripper struct {
 	// Transport is the underlying http.RoundTripper being wrapped. Required.
 	Transport http.RoundTripper
-
-	// StaticToken is the pre-configured bearer token. Optional.
-	StaticToken string
-
-	// OverrideFromCtx enables reading bearer token from Context.
-	OverrideFromCtx bool
+	Auths     []Method
 }
 
 // RoundTrip injects the outbound Authorization header with the
@@ -29,15 +36,29 @@ func (tr RoundTripper) RoundTrip(r *http.Request) (*http.Response, error) {
 	if tr.Transport == nil {
 		return nil, errors.New("no http.RoundTripper provided")
 	}
-	token := tr.StaticToken
-	if tr.OverrideFromCtx {
-		headerToken, _ := bearertoken.GetBearerToken(r.Context())
-		if headerToken != "" {
-			token = headerToken
+
+	req := r.Clone(r.Context())
+
+	for _, auth := range tr.Auths {
+		token := ""
+
+		// Get token from context if available
+		if auth.FromCtx != nil {
+			if t, ok := auth.FromCtx(r.Context()); ok {
+				token = t
+			}
+		}
+
+		// Fall back to TokenFn if no token from context
+		if token == "" && auth.TokenFn != nil {
+			token = auth.TokenFn()
+		}
+
+		// Add Authorization header if we have a token
+		if token != "" {
+			req.Header.Add("Authorization", fmt.Sprintf("%s %s", auth.Scheme, token))
 		}
 	}
-	if token != "" {
-		r.Header.Set("Authorization", "Bearer "+token)
-	}
-	return tr.Transport.RoundTrip(r)
+
+	return tr.Transport.RoundTrip(req)
 }
diff --git a/internal/config/promcfg/config.go b/internal/config/promcfg/config.go
index 864a5333..e029c13d 100644
--- a/internal/config/promcfg/config.go
+++ b/internal/config/promcfg/config.go
@@ -14,7 +14,8 @@ import (
 type Configuration struct {
 	ServerURL      string        `valid:"required" mapstructure:"endpoint"`
 	ConnectTimeout time.Duration `mapstructure:"connect_timeout"`
-	TLS            configtls.ClientConfig
+	// TLS contains the TLS configuration for the connection to the Prometheus clusters.
+	TLS configtls.ClientConfig `mapstructure:"tls"`
 
 	TokenFilePath            string `mapstructure:"token_file_path"`
 	TokenOverrideFromContext bool   `mapstructure:"token_override_from_context"`
diff --git a/internal/converter/thrift/jaeger/from_domain.go b/internal/converter/thrift/jaeger/from_domain.go
deleted file mode 100644
index 7b68c5a3..00000000
--- a/internal/converter/thrift/jaeger/from_domain.go
+++ /dev/null
@@ -1,146 +0,0 @@
-// Copyright (c) 2019 The Jaeger Authors.
-// Copyright (c) 2017 Uber Technologies, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package jaeger
-
-import (
-	"fmt"
-
-	"github.com/jaegertracing/jaeger-idl/model/v1"
-	"github.com/jaegertracing/jaeger-idl/thrift-gen/jaeger"
-)
-
-// FromDomain takes an array of model.Span and returns
-// an array of jaeger.Span.  If errors are found during
-// conversion of tags, then error tags are appended.
-func FromDomain(spans []*model.Span) []*jaeger.Span {
-	jSpans := make([]*jaeger.Span, len(spans))
-	dToJ := domainToJaegerTransformer{}
-	for idx, span := range spans {
-		jSpans[idx] = dToJ.transformSpan(span)
-	}
-	return jSpans
-}
-
-// FromDomainSpan takes a single model.Span and
-// converts it into a jaeger.Span.  If errors are found
-// during conversion of tags, then error tags are appended.
-func FromDomainSpan(span *model.Span) *jaeger.Span {
-	dToJ := &domainToJaegerTransformer{}
-	return dToJ.transformSpan(span)
-}
-
-type domainToJaegerTransformer struct{}
-
-func (domainToJaegerTransformer) keyValueToTag(kv *model.KeyValue) *jaeger.Tag {
-	if kv.VType == model.StringType {
-		stringValue := kv.VStr
-		return &jaeger.Tag{
-			Key:   kv.Key,
-			VType: jaeger.TagType_STRING,
-			VStr:  &stringValue,
-		}
-	}
-
-	if kv.VType == model.Int64Type {
-		intValue := kv.Int64()
-		return &jaeger.Tag{
-			Key:   kv.Key,
-			VType: jaeger.TagType_LONG,
-			VLong: &intValue,
-		}
-	}
-
-	if kv.VType == model.BinaryType {
-		binaryValue := kv.Binary()
-		return &jaeger.Tag{
-			Key:     kv.Key,
-			VType:   jaeger.TagType_BINARY,
-			VBinary: binaryValue,
-		}
-	}
-
-	if kv.VType == model.BoolType {
-		boolValue := kv.Bool()
-		return &jaeger.Tag{
-			Key:   kv.Key,
-			VType: jaeger.TagType_BOOL,
-			VBool: &boolValue,
-		}
-	}
-
-	if kv.VType == model.Float64Type {
-		floatValue := kv.Float64()
-		return &jaeger.Tag{
-			Key:     kv.Key,
-			VType:   jaeger.TagType_DOUBLE,
-			VDouble: &floatValue,
-		}
-	}
-
-	errString := fmt.Sprintf("No suitable tag type found for: %#v", kv.VType)
-	errTag := &jaeger.Tag{
-		Key:   "Error",
-		VType: jaeger.TagType_STRING,
-		VStr:  &errString,
-	}
-
-	return errTag
-}
-
-func (d domainToJaegerTransformer) convertKeyValuesToTags(kvs model.KeyValues) []*jaeger.Tag {
-	jaegerTags := make([]*jaeger.Tag, len(kvs))
-	for idx, kv := range kvs {
-		jaegerTags[idx] = d.keyValueToTag(&kv)
-	}
-	return jaegerTags
-}
-
-func (d domainToJaegerTransformer) convertLogs(logs []model.Log) []*jaeger.Log {
-	jaegerLogs := make([]*jaeger.Log, len(logs))
-	for idx, log := range logs {
-		jaegerLogs[idx] = &jaeger.Log{
-			//nolint: gosec // G115
-			Timestamp: int64(model.TimeAsEpochMicroseconds(log.Timestamp)),
-			Fields:    d.convertKeyValuesToTags(log.Fields),
-		}
-	}
-	return jaegerLogs
-}
-
-func (domainToJaegerTransformer) convertSpanRefs(refs []model.SpanRef) []*jaeger.SpanRef {
-	jaegerSpanRefs := make([]*jaeger.SpanRef, len(refs))
-	for idx, ref := range refs {
-		//nolint: gosec // G115
-		jaegerSpanRefs[idx] = &jaeger.SpanRef{
-			RefType:     jaeger.SpanRefType(ref.RefType),
-			TraceIdLow:  int64(ref.TraceID.Low),
-			TraceIdHigh: int64(ref.TraceID.High),
-			SpanId:      int64(ref.SpanID),
-		}
-	}
-	return jaegerSpanRefs
-}
-
-func (d domainToJaegerTransformer) transformSpan(span *model.Span) *jaeger.Span {
-	tags := d.convertKeyValuesToTags(span.Tags)
-	logs := d.convertLogs(span.Logs)
-	refs := d.convertSpanRefs(span.References)
-
-	//nolint: gosec // G115
-	jaegerSpan := &jaeger.Span{
-		TraceIdLow:    int64(span.TraceID.Low),
-		TraceIdHigh:   int64(span.TraceID.High),
-		SpanId:        int64(span.SpanID),
-		ParentSpanId:  int64(span.ParentSpanID()),
-		OperationName: span.OperationName,
-		References:    refs,
-		Flags:         int32(span.Flags),
-		StartTime:     int64(model.TimeAsEpochMicroseconds(span.StartTime)),
-		Duration:      int64(model.DurationAsMicroseconds(span.Duration)),
-		Tags:          tags,
-		Logs:          logs,
-	}
-	return jaegerSpan
-}
diff --git a/internal/jptrace/utf8.go b/internal/jptrace/utf8.go
deleted file mode 100644
index 45348091..00000000
--- a/internal/jptrace/utf8.go
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright (c) 2025 The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package jptrace
-
-import (
-	"golang.org/x/text/runes"
-	"golang.org/x/text/transform"
-)
-
-func SanitizeUTF8(input string) (string, error) {
-	t := transform.Chain(runes.ReplaceIllFormed(), transform.Nop)
-	sanitized, _, err := transform.String(t, input)
-	return sanitized, err
-}
diff --git a/internal/storage/elasticsearch/config/auth_helper.go b/internal/storage/elasticsearch/config/auth_helper.go
new file mode 100644
index 00000000..c3b8f60a
--- /dev/null
+++ b/internal/storage/elasticsearch/config/auth_helper.go
@@ -0,0 +1,55 @@
+// Copyright (c) 2025 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package config
+
+import (
+	"context"
+	"time"
+
+	"go.uber.org/zap"
+
+	"github.com/jaegertracing/jaeger/internal/auth"
+	"github.com/jaegertracing/jaeger/internal/auth/bearertoken"
+)
+
+// initBearerAuth initializes bearer token authentication method
+func initBearerAuth(bearerAuth *BearerTokenAuthentication, logger *zap.Logger) (*auth.Method, error) {
+	return initBearerAuthWithTime(bearerAuth, logger, time.Now)
+}
+
+// initBearerAuthWithTime initializes bearer token authentication method with injectable time for testing
+func initBearerAuthWithTime(bearerAuth *BearerTokenAuthentication, logger *zap.Logger, timeFn func() time.Time) (*auth.Method, error) {
+	if bearerAuth == nil || (bearerAuth.FilePath == "" && !bearerAuth.AllowFromContext) {
+		return nil, nil
+	}
+
+	if bearerAuth.FilePath != "" && bearerAuth.AllowFromContext {
+		logger.Warn("Both Bearer Token file and context propagation are enabled - context token will take precedence over file-based token")
+	}
+
+	var tokenFn func() string
+	var fromCtx func(context.Context) (string, bool)
+
+	// file-based token setup
+	if bearerAuth.FilePath != "" {
+		reloadInterval := bearerAuth.ReloadInterval
+		tf, err := auth.TokenProviderWithTime(bearerAuth.FilePath, reloadInterval, logger, timeFn)
+		if err != nil {
+			return nil, err
+		}
+		tokenFn = tf
+	}
+
+	// context-based token setup
+	if bearerAuth.AllowFromContext {
+		fromCtx = bearertoken.GetBearerToken
+	}
+
+	// Return pointer to the auth method
+	return &auth.Method{
+		Scheme:  "Bearer",
+		TokenFn: tokenFn,
+		FromCtx: fromCtx,
+	}, nil
+}
diff --git a/internal/storage/elasticsearch/config/config.go b/internal/storage/elasticsearch/config/config.go
index 16ee3abf..09e42cd7 100644
--- a/internal/storage/elasticsearch/config/config.go
+++ b/internal/storage/elasticsearch/config/config.go
@@ -219,6 +219,9 @@ type BearerTokenAuthentication struct {
 	FilePath string `mapstructure:"file_path"`
 	// AllowTokenFromContext, if set to true, enables reading bearer token from the context.
 	AllowFromContext bool `mapstructure:"from_context"`
+	// ReloadInterval contains the interval at which the bearer token file is reloaded.
+	// If set to 0 then the file is only loaded once on startup.
+	ReloadInterval time.Duration `mapstructure:"reload_interval"`
 }
 
 // NewClient creates a new ElasticSearch client
@@ -641,29 +644,27 @@ func GetHTTPRoundTripper(ctx context.Context, c *Configuration, logger *zap.Logg
 		transport.TLSClientConfig = tlsConfig
 	}
 
-	// Wrap with authentication layer if configured.
-	var roundTripper http.RoundTripper = transport
+	// Initialize authentication methods.
+	var authMethods []auth.Method
 
+	// Bearer Token Authentication
 	if c.Authentication.BearerTokenAuthentication.HasValue() {
 		bearerAuth := c.Authentication.BearerTokenAuthentication.Get()
-		if bearerAuth.AllowFromContext || bearerAuth.FilePath != "" {
-			token := ""
-			if bearerAuth.FilePath != "" {
-				if bearerAuth.AllowFromContext {
-					logger.Warn("Token file and token propagation are both enabled, token from file won't be used")
-				}
-				tokenFromFile, err := loadTokenFromFile(bearerAuth.FilePath)
-				if err != nil {
-					return nil, err
-				}
-				token = tokenFromFile
-			}
+		ba, err := initBearerAuth(bearerAuth, logger)
+		if err != nil {
+			return nil, fmt.Errorf("failed to initialize bearer authentication: %w", err)
+		}
+		if ba != nil {
+			authMethods = append(authMethods, *ba)
+		}
+	}
 
-			roundTripper = &auth.RoundTripper{
-				Transport:       transport,
-				OverrideFromCtx: bearerAuth.AllowFromContext,
-				StaticToken:     token,
-			}
+	// Wrap with authentication layer.
+	var roundTripper http.RoundTripper = transport
+	if len(authMethods) > 0 {
+		roundTripper = &auth.RoundTripper{
+			Transport: transport,
+			Auths:     authMethods,
 		}
 	}
 
diff --git a/internal/storage/elasticsearch/query/range_query.go b/internal/storage/elasticsearch/query/range_query.go
new file mode 100644
index 00000000..c461366e
--- /dev/null
+++ b/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
+}
diff --git a/internal/storage/metricstore/elasticsearch/query_builder.go b/internal/storage/metricstore/elasticsearch/query_builder.go
index f632d2c0..15473e5d 100644
--- a/internal/storage/metricstore/elasticsearch/query_builder.go
+++ b/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")
diff --git a/internal/storage/metricstore/prometheus/metricstore/reader.go b/internal/storage/metricstore/prometheus/metricstore/reader.go
index cf3aa2d5..19f33a75 100644
--- a/internal/storage/metricstore/prometheus/metricstore/reader.go
+++ b/internal/storage/metricstore/prometheus/metricstore/reader.go
@@ -9,8 +9,6 @@ import (
 	"net"
 	"net/http"
 	"net/url"
-	"os"
-	"path/filepath"
 	"strings"
 	"time"
 	"unicode"
@@ -23,6 +21,7 @@ import (
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger/internal/auth"
+	"github.com/jaegertracing/jaeger/internal/auth/bearertoken"
 	config "github.com/jaegertracing/jaeger/internal/config/promcfg"
 	"github.com/jaegertracing/jaeger/internal/proto-gen/api_v2/metrics"
 	"github.com/jaegertracing/jaeger/internal/storage/metricstore/prometheus/metricstore/dbmodel"
@@ -362,26 +361,32 @@ func getHTTPRoundTripper(c *config.Configuration) (rt http.RoundTripper, err err
 		TLSHandshakeTimeout: 10 * time.Second,
 		TLSClientConfig:     ctlsConfig,
 	}
-
-	token := ""
+	// dynamic token loader with interval-based caching
+	var tokenFn func() string
 	if c.TokenFilePath != "" {
-		tokenFromFile, err := loadToken(c.TokenFilePath)
+		var err error
+		tokenFn, err = auth.TokenProvider(
+			c.TokenFilePath,
+			10*time.Second,
+			nil,
+		)
 		if err != nil {
 			return nil, err
 		}
-		token = tokenFromFile
+	}
+	// Only set FromCtxFn if token override from context is enabled
+	var fromCtxFn func(context.Context) (string, bool)
+	if c.TokenOverrideFromContext {
+		fromCtxFn = bearertoken.GetBearerToken
 	}
 	return &auth.RoundTripper{
-		Transport:       httpTransport,
-		OverrideFromCtx: c.TokenOverrideFromContext,
-		StaticToken:     token,
+		Transport: httpTransport,
+		Auths: []auth.Method{
+			{
+				Scheme:  "Bearer",
+				TokenFn: tokenFn,
+				FromCtx: fromCtxFn,
+			},
+		},
 	}, nil
 }
-
-func loadToken(path string) (string, error) {
-	b, err := os.ReadFile(filepath.Clean(path))
-	if err != nil {
-		return "", fmt.Errorf("failed to get token from file: %w", err)
-	}
-	return strings.TrimRight(string(b), "\r\n"), nil
-}
diff --git a/internal/storage/v1/elasticsearch/options.go b/internal/storage/v1/elasticsearch/options.go
index 1f084701..e9b7391a 100644
--- a/internal/storage/v1/elasticsearch/options.go
+++ b/internal/storage/v1/elasticsearch/options.go
@@ -24,7 +24,8 @@ const (
 	suffixDisableHealthCheck             = ".disable-health-check"
 	suffixSnifferTLSEnabled              = ".sniffer-tls-enabled"
 	suffixTokenPath                      = ".token-file"
-	suffixBearerTokenPropagation         = ".bearer-token-propagation" // #nosec G101
+	suffixBearerTokenPropagation         = ".bearer-token-propagation"     // #nosec G101
+	suffixBearerTokenReloadInterval      = ".bearer-token-reload-interval" //#nosec G101
 	suffixPasswordPath                   = ".password-file"
 	suffixServerURLs                     = ".server-urls"
 	suffixRemoteReadClusters             = ".remote-read-clusters"
@@ -143,6 +144,7 @@ func addFlags(flagSet *flag.FlagSet, nsConfig *namespaceConfig) {
 		passwordPath                string
 		tokenPath                   string
 		bearerTokenAllowFromContext bool
+		reloadInterval              time.Duration = 10 * time.Second
 	)
 
 	if nsConfig.Authentication.BasicAuthentication.HasValue() {
@@ -156,6 +158,9 @@ func addFlags(flagSet *flag.FlagSet, nsConfig *namespaceConfig) {
 		bearerAuth := nsConfig.Authentication.BearerTokenAuthentication.Get()
 		tokenPath = bearerAuth.FilePath
 		bearerTokenAllowFromContext = bearerAuth.AllowFromContext
+		if bearerAuth.ReloadInterval != 0 {
+			reloadInterval = bearerAuth.ReloadInterval
+		}
 	}
 
 	flagSet.String(
@@ -171,6 +176,10 @@ func addFlags(flagSet *flag.FlagSet, nsConfig *namespaceConfig) {
 		tokenPath,
 		"Path to a file containing bearer token. This flag also loads CA if it is specified.")
 
+	flagSet.Duration(
+		nsConfig.namespace+suffixBearerTokenReloadInterval,
+		reloadInterval,
+		"Interval for reloading bearer token from file. Set to 0 to disable automatic reloading.")
 	flagSet.Bool(
 		nsConfig.namespace+suffixBearerTokenPropagation,
 		bearerTokenAllowFromContext,
@@ -361,15 +370,15 @@ func initFromViper(cfg *namespaceConfig, v *viper.Viper) {
 	// BearerAuthentication if tokenPath or allowFromContext is set
 	tokenPath := v.GetString(cfg.namespace + suffixTokenPath)
 	bearerTokenAllowFromContext := v.GetBool(cfg.namespace + suffixBearerTokenPropagation)
-
 	// Create BearerTokenAuthentication if either field is configured
 	if tokenPath != "" || bearerTokenAllowFromContext {
+		reloadInterval := v.GetDuration(cfg.namespace + suffixBearerTokenReloadInterval)
 		cfg.Authentication.BearerTokenAuthentication = configoptional.Some(config.BearerTokenAuthentication{
 			FilePath:         tokenPath,
 			AllowFromContext: bearerTokenAllowFromContext,
+			ReloadInterval:   reloadInterval,
 		})
 	}
-
 	cfg.Sniffing.Enabled = v.GetBool(cfg.namespace + suffixSniffer)
 	cfg.Sniffing.UseHTTPS = v.GetBool(cfg.namespace + suffixSnifferTLSEnabled)
 	cfg.DisableHealthCheck = v.GetBool(cfg.namespace + suffixDisableHealthCheck)
diff --git a/internal/storage/v1/elasticsearch/samplingstore/storage.go b/internal/storage/v1/elasticsearch/samplingstore/storage.go
index dd110da3..5c0f93ef 100644
--- a/internal/storage/v1/elasticsearch/samplingstore/storage.go
+++ b/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 {
diff --git a/internal/storage/v1/elasticsearch/spanstore/reader.go b/internal/storage/v1/elasticsearch/spanstore/reader.go
index 16bcff8a..412c00ba 100644
--- a/internal/storage/v1/elasticsearch/spanstore/reader.go
+++ b/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 {
diff --git a/internal/storage/v2/elasticsearch/depstore/storage.go b/internal/storage/v2/elasticsearch/depstore/storage.go
index 67184362..526875a2 100644
--- a/internal/storage/v2/elasticsearch/depstore/storage.go
+++ b/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 {



Test patch:
diff --git a/cmd/all-in-one/setupcontext/setupcontext_test.go b/cmd/all-in-one/setupcontext/setupcontext_test.go
deleted file mode 100644
index 5da20a0e..00000000
--- a/cmd/all-in-one/setupcontext/setupcontext_test.go
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright (c) 2019 The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package setupcontext
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/jaegertracing/jaeger/internal/testutils"
-)
-
-func TestSetupContext(t *testing.T) {
-	// purely for code coverage
-	SetAllInOne()
-	defer UnsetAllInOne()
-	assert.True(t, IsAllInOne())
-}
-
-func TestMain(m *testing.M) {
-	testutils.VerifyGoLeaks(m)
-}
diff --git a/internal/auth/tokenloader_test.go b/internal/auth/tokenloader_test.go
new file mode 100644
index 00000000..e49842e3
--- /dev/null
+++ b/internal/auth/tokenloader_test.go
@@ -0,0 +1,316 @@
+// Copyright (c) 2025 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package auth
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+	"go.uber.org/zap/zaptest/observer"
+)
+
+// TestCachedFileTokenLoader_Deterministic covers basic cache and reload logic with mock time
+func TestCachedFileTokenLoader_Deterministic(t *testing.T) {
+	currentTime := time.Unix(0, 0)
+	timeFn := func() time.Time { return currentTime }
+
+	tokenFile := createTempTokenFile(t, "my-secret-token\n")
+
+	loader := cachedFileTokenLoader(tokenFile, 100*time.Millisecond, timeFn)
+
+	// T=0: First load - should read from file
+	token1, err := loader()
+	require.NoError(t, err)
+	assert.Equal(t, "my-secret-token", token1)
+
+	// Change the file content
+	updateTokenFile(t, tokenFile, "new-token\n")
+
+	// T=50ms: Still within cache interval (< 100ms)
+	currentTime = currentTime.Add(50 * time.Millisecond)
+	token2, err := loader()
+	require.NoError(t, err)
+	assert.Equal(t, "my-secret-token", token2, "Should return cached token within interval")
+
+	// T=150ms: Beyond cache interval (> 100ms)
+	currentTime = currentTime.Add(100 * time.Millisecond) // Total: 150ms
+	token3, err := loader()
+	require.NoError(t, err)
+	assert.Equal(t, "new-token", token3, "Should return refreshed token after cache expires")
+}
+
+// TestCachedFileTokenLoader_ExactBoundaries tests exact cache boundary conditions
+func TestCachedFileTokenLoader_ExactBoundaries(t *testing.T) {
+	currentTime := time.Unix(0, 0)
+	timeFn := func() time.Time { return currentTime }
+	tokenFile := createTempTokenFile(t, "boundary-token\n")
+	cacheInterval := 200 * time.Millisecond
+
+	loader := cachedFileTokenLoader(tokenFile, cacheInterval, timeFn)
+
+	// Load initial token
+	token, err := loader()
+	require.NoError(t, err)
+	assert.Equal(t, "boundary-token", token)
+
+	// Update file
+	updateTokenFile(t, tokenFile, "boundary-updated\n")
+
+	// Test exact boundary conditions
+	testCases := []struct {
+		timeAdvance   time.Duration
+		expectedToken string
+		description   string
+	}{
+		{199 * time.Millisecond, "boundary-token", "1ms before cache expires"},
+		{1 * time.Millisecond, "boundary-updated", "exactly at cache expiry"},
+		{50 * time.Millisecond, "boundary-updated", "well past cache expiry"},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.description, func(t *testing.T) {
+			currentTime = currentTime.Add(tc.timeAdvance)
+			token, err := loader()
+			require.NoError(t, err)
+			assert.Equal(t, tc.expectedToken, token, tc.description)
+		})
+	}
+}
+
+// TestCachedFileTokenLoader_ZeroInterval tests disabled reloading
+func TestCachedFileTokenLoader_ZeroInterval(t *testing.T) {
+	currentTime := time.Unix(0, 0)
+	timeFn := func() time.Time { return currentTime }
+	tokenFile := createTempTokenFile(t, "initial-token\n")
+	loader := cachedFileTokenLoader(tokenFile, 0, timeFn) // Zero interval = no reloading
+
+	// T=0: Initial load
+	token, err := loader()
+	require.NoError(t, err)
+	assert.Equal(t, "initial-token", token)
+
+	// Update file content
+	updateTokenFile(t, tokenFile, "updated-token\n")
+
+	// Should still return cached token (no reloading)
+	currentTime = currentTime.Add(1 * time.Hour) // Advance time significantly
+	token, err = loader()
+	require.NoError(t, err)
+	assert.Equal(t, "initial-token", token, "Zero interval should disable reloading completely")
+
+	// Multiple calls should continue returning cached token
+	for i := 0; i < 5; i++ {
+		// Generate different content for each iteration
+		newContent := fmt.Sprintf("different-token-%d-%d\n", i, currentTime.Unix())
+		updateTokenFile(t, tokenFile, newContent)
+
+		currentTime = currentTime.Add(1 * time.Hour)
+		token, err = loader()
+		require.NoError(t, err)
+		assert.Equal(t, "initial-token", token,
+			"Should always return initially cached token despite file change to %s at time %v",
+			strings.TrimSpace(newContent), currentTime)
+	}
+}
+
+// TestNewTokenProvider_InitialLoad covers initial load and fail-fast scenarios
+func TestNewTokenProvider_InitialLoad(t *testing.T) {
+	// Test successful initial load
+	tokenFile := createTempTokenFile(t, "initial-token\n")
+
+	tokenFn, err := TokenProvider(tokenFile, 100*time.Millisecond, nil)
+	require.NoError(t, err, "TokenProvider should not fail with valid token file")
+	assert.Equal(t, "initial-token", tokenFn(), "Token should match file contents")
+
+	// Test fail-fast on invalid file
+	_, err = TokenProvider("/nonexistent/file", 100*time.Millisecond, nil)
+	require.Error(t, err, "TokenProvider should fail fast on missing file")
+	assert.Contains(t, err.Error(), "failed to get token from file", "Error message should indicate token loading failure")
+
+	// Test empty file
+	emptyFile := createTempTokenFile(t, "")
+	tokenFn, err = TokenProvider(emptyFile, 100*time.Millisecond, nil)
+	require.NoError(t, err)
+	assert.Empty(t, tokenFn(), "Empty file should return empty token")
+	// Test file with trailing whitespace - properly trimmed
+	whitespaceFile := createTempTokenFile(t, "my-secret-token\r\n")
+	tokenFn, err = TokenProvider(whitespaceFile, 100*time.Millisecond, nil)
+	require.NoError(t, err)
+	assert.Equal(t, "my-secret-token", tokenFn(), "\\r\\n should be properly trimmed from end")
+}
+
+// TestNewTokenProvider_ReloadErrors_Deterministic ensures reload errors log and return cached token
+func TestNewTokenProvider_ReloadErrors_Deterministic(t *testing.T) {
+	currentTime := time.Unix(0, 0)
+	timeFn := func() time.Time { return currentTime }
+	tokenFile := createTempTokenFile(t, "initial-token\n")
+
+	// Create an observed zap logger
+	core, logs := observer.New(zapcore.InfoLevel)
+	logger := zap.New(core)
+
+	// Initialize token provider with mock time
+	tokenFn, err := TokenProviderWithTime(tokenFile, 10*time.Millisecond, logger, timeFn)
+	require.NoError(t, err)
+
+	// Initial call should succeed
+	token := tokenFn()
+	assert.Equal(t, "initial-token", token)
+
+	// Remove the file to force reload error
+	os.Remove(tokenFile)
+
+	// Advance time beyond cache interval
+	currentTime = currentTime.Add(15 * time.Millisecond)
+
+	// Call should return last cached token and log error
+	token = tokenFn()
+	assert.Equal(t, "initial-token", token, "Should return cached token even after file deletion")
+
+	// Verify the error was logged
+	require.Equal(t, 1, logs.Len(), "Expected one log message")
+	logEntry := logs.All()[0]
+	assert.Equal(t, "Token reload failed", logEntry.Message, "Expected log message to match")
+	assert.Equal(t, zapcore.WarnLevel, logEntry.Level, "Expected warning level log")
+}
+
+// TestTokenProviderWithTime_DirectCall tests the time-injectable function directly
+func TestTokenProviderWithTime_DirectCall(t *testing.T) {
+	currentTime := time.Unix(0, 0)
+	timeFn := func() time.Time { return currentTime }
+	tokenFile := createTempTokenFile(t, "time-test-token\n")
+	logger := zap.NewNop()
+
+	// Create token provider with mock time
+	tokenFn, err := TokenProviderWithTime(tokenFile, 200*time.Millisecond, logger, timeFn)
+	require.NoError(t, err)
+	require.NotNil(t, tokenFn)
+
+	// Test initial token
+	token := tokenFn()
+	assert.Equal(t, "time-test-token", token)
+
+	// Update file
+	updateTokenFile(t, tokenFile, "time-updated\n")
+
+	// Should still return cached token
+	currentTime = currentTime.Add(100 * time.Millisecond)
+	token = tokenFn()
+	assert.Equal(t, "time-test-token", token)
+
+	// Should return updated token after cache expires
+	currentTime = currentTime.Add(150 * time.Millisecond)
+	token = tokenFn()
+	assert.Equal(t, "time-updated", token)
+}
+
+// TestNewTokenProvider_WithZapLogger ensures zap logger is used properly
+func TestNewTokenProvider_WithZapLogger(t *testing.T) {
+	currentTime := time.Unix(0, 0)
+	timeFn := func() time.Time { return currentTime }
+	tokenFile := createTempTokenFile(t, "initial-token\n")
+
+	// Create an observed zap logger
+	core, logs := observer.New(zapcore.InfoLevel)
+	logger := zap.New(core)
+
+	// Initialize token provider with structured logger
+	tokenFn, err := TokenProviderWithTime(tokenFile, 10*time.Millisecond, logger, timeFn)
+	require.NoError(t, err)
+
+	// Initial call should succeed
+	token := tokenFn()
+	assert.Equal(t, "initial-token", token)
+
+	// No logs yet
+	assert.Equal(t, 0, logs.Len(), "No logs should be emitted for successful loads")
+
+	// Remove the file to force reload error
+	os.Remove(tokenFile)
+
+	// Advance time to trigger reload
+	currentTime = currentTime.Add(15 * time.Millisecond)
+
+	// Call should log using zap logger
+	tokenFn()
+	assert.Equal(t, 1, logs.Len(), "Error should be logged using zap")
+
+	logEntry := logs.All()[0]
+	assert.Equal(t, "Token reload failed", logEntry.Message, "Log message should match")
+	assert.NotNil(t, logEntry.Context[0].Interface, "Error should be attached to log")
+}
+
+// TestCachedFileTokenLoader_FilePermissions tests file permission errors
+func TestCachedFileTokenLoader_FilePermissions(t *testing.T) {
+	if os.Getuid() == 0 {
+		t.Skip("Running as root - file permission tests not meaningful")
+	}
+
+	currentTime := time.Unix(0, 0)
+	timeFn := func() time.Time { return currentTime }
+
+	// Create a file and make it unreadable
+	tokenFile := createTempTokenFile(t, "permission-test\n")
+	err := os.Chmod(tokenFile, 0o000) // No permissions
+	require.NoError(t, err)
+
+	// Cleanup with restored permissions
+	t.Cleanup(func() {
+		os.Chmod(tokenFile, 0o644)
+		os.Remove(tokenFile)
+	})
+
+	loader := cachedFileTokenLoader(tokenFile, 100*time.Millisecond, timeFn)
+
+	// Should return permission error
+	_, err = loader()
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "permission denied")
+}
+
+func TestTokenProvider_Wrapper(t *testing.T) {
+	tokenFile := createTempTokenFile(t, "production-test-token\n")
+	logger := zap.NewNop()
+
+	// Test that TokenProvider uses real time
+	tokenFn, err := TokenProvider(tokenFile, 100*time.Millisecond, logger)
+	require.NoError(t, err)
+
+	token := tokenFn()
+	assert.Equal(t, "production-test-token", token)
+}
+
+// Helper functions
+
+// createTempTokenFile creates a temp file with the given content and returns its name
+func createTempTokenFile(t *testing.T, content string) string {
+	t.Helper()
+
+	tmpFile, err := os.CreateTemp(t.TempDir(), "token-*.txt")
+	require.NoError(t, err, "Failed to create temp file")
+
+	_, err = tmpFile.WriteString(content)
+	require.NoError(t, err, "Failed to write to temp file")
+
+	err = tmpFile.Close()
+	require.NoError(t, err, "Failed to close temp file")
+
+	// Cleanup happens automatically with t.TempDir()
+	return tmpFile.Name()
+}
+
+// updateTokenFile updates an existing token file with new content
+func updateTokenFile(t *testing.T, filename, content string) {
+	t.Helper()
+
+	err := os.WriteFile(filename, []byte(content), 0o600)
+	require.NoError(t, err, "Failed to update token file")
+}
diff --git a/internal/auth/transport_test.go b/internal/auth/transport_test.go
index 6747d8c1..a70e9745 100644
--- a/internal/auth/transport_test.go
+++ b/internal/auth/transport_test.go
@@ -6,7 +6,6 @@ package auth
 import (
 	"context"
 	"net/http"
-	"net/http/httptest"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -22,80 +21,135 @@ func (s roundTripFunc) RoundTrip(r *http.Request) (*http.Response, error) {
 }
 
 func TestRoundTripper(t *testing.T) {
-	for _, tc := range []struct {
-		name             string
-		staticToken      string
-		overrideFromCtx  bool
-		wrappedTransport http.RoundTripper
-		requestContext   context.Context
-		wantError        bool
+	tests := []struct {
+		name               string
+		auths              []Method
+		requestContext     context.Context
+		expectedHeaders    []string // Expected Authorization headers
+		expectError        bool
+		expectNoAuthHeader bool
 	}{
 		{
-			name: "Default RoundTripper and request context set should have empty Bearer token",
-			wrappedTransport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-				assert.Empty(t, r.Header.Get("Authorization"))
-				return &http.Response{
-					StatusCode: http.StatusOK,
-				}, nil
-			}),
-			requestContext: bearertoken.ContextWithBearerToken(context.Background(), "tokenFromContext"),
+			name:               "No auth configs - no headers added",
+			auths:              []Method{},
+			requestContext:     context.Background(),
+			expectNoAuthHeader: true,
 		},
 		{
-			name:            "Override from context provided, and request context set should use request context token",
-			overrideFromCtx: true,
-			wrappedTransport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-				assert.Equal(t, "Bearer tokenFromContext", r.Header.Get("Authorization"))
-				return &http.Response{
-					StatusCode: http.StatusOK,
-				}, nil
-			}),
-			requestContext: bearertoken.ContextWithBearerToken(context.Background(), "tokenFromContext"),
+			name: "Single Bearer auth with static token",
+			auths: []Method{
+				{
+					Scheme:  "Bearer",
+					TokenFn: func() string { return "static-token" },
+				},
+			},
+			requestContext:  context.Background(),
+			expectedHeaders: []string{"Bearer static-token"},
 		},
 		{
-			name:            "Allow override from context and token provided, and request context unset should use defaultToken",
-			overrideFromCtx: true,
-			staticToken:     "initToken",
-			wrappedTransport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-				assert.Equal(t, "Bearer initToken", r.Header.Get("Authorization"))
-				return &http.Response{}, nil
-			}),
-			requestContext: context.Background(),
+			name: "Bearer auth with context override - context token used",
+			auths: []Method{
+				{
+					Scheme:  "Bearer",
+					TokenFn: func() string { return "static-token" },
+					FromCtx: bearertoken.GetBearerToken,
+				},
+			},
+			requestContext:  bearertoken.ContextWithBearerToken(context.Background(), "context-token"),
+			expectedHeaders: []string{"Bearer context-token"},
+		},
+		{
+			name: "Multiple auth methods - both tokens added",
+			auths: []Method{
+				{
+					Scheme:  "Bearer",
+					TokenFn: func() string { return "bearer-token" },
+				},
+				{
+					Scheme:  "ApiKey",
+					TokenFn: func() string { return "api-key-value" },
+				},
+			},
+			requestContext:  context.Background(),
+			expectedHeaders: []string{"Bearer bearer-token", "ApiKey api-key-value"},
+		},
+		{
+			name: "Auth config with empty token - no header added",
+			auths: []Method{
+				{
+					Scheme:  "Bearer",
+					TokenFn: func() string { return "" }, // Empty token
+				},
+				{
+					Scheme:  "ApiKey",
+					TokenFn: func() string { return "valid-key" },
+				},
+			},
+			requestContext:  context.Background(),
+			expectedHeaders: []string{"ApiKey valid-key"}, // Only valid token
 		},
 		{
-			name:            "Allow override from context and token provided, and request context set should use context token",
-			overrideFromCtx: true,
-			staticToken:     "initToken",
-			wrappedTransport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-				assert.Equal(t, "Bearer tokenFromContext", r.Header.Get("Authorization"))
-				return &http.Response{}, nil
-			}),
-			requestContext: bearertoken.ContextWithBearerToken(context.Background(), "tokenFromContext"),
+			name: "Only context extraction, no context token - no header added",
+			auths: []Method{
+				{
+					Scheme:  "Bearer",
+					FromCtx: bearertoken.GetBearerToken,
+				},
+			},
+			requestContext:     context.Background(),
+			expectNoAuthHeader: true,
 		},
 		{
-			name:           "Nil roundTripper provided should return an error",
+			name:           "Nil transport - should return error",
+			auths:          []Method{},
 			requestContext: context.Background(),
-			wantError:      true,
+			expectError:    true,
 		},
-	} {
+	}
+
+	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			server := httptest.NewServer(nil)
-			defer server.Close()
-			req, err := http.NewRequestWithContext(tc.requestContext, http.MethodGet, server.URL, nil)
+			t.Parallel() // Enable parallel execution for faster tests
+
+			// Each test gets its own isolated capturedRequest and transport
+			var capturedRequest *http.Request
+			wrappedTransport := roundTripFunc(func(r *http.Request) (*http.Response, error) {
+				capturedRequest = r
+				return &http.Response{StatusCode: http.StatusOK}, nil
+			})
+
+			req, err := http.NewRequestWithContext(tc.requestContext, http.MethodGet, "http://fake.example.com/api", nil)
 			require.NoError(t, err)
 
+			var transport http.RoundTripper = wrappedTransport
+			if tc.expectError {
+				transport = nil // Force nil transport for error test
+			}
+
 			tr := RoundTripper{
-				Transport:       tc.wrappedTransport,
-				OverrideFromCtx: tc.overrideFromCtx,
-				StaticToken:     tc.staticToken,
+				Transport: transport,
+				Auths:     tc.auths,
 			}
+
 			resp, err := tr.RoundTrip(req)
 
-			if tc.wantError {
+			if tc.expectError {
 				assert.Nil(t, resp)
 				require.Error(t, err)
-			} else {
-				assert.NotNil(t, resp)
-				require.NoError(t, err)
+				assert.Contains(t, err.Error(), "no http.RoundTripper provided")
+				return
+			}
+
+			require.NoError(t, err)
+			assert.NotNil(t, resp)
+			require.NotNil(t, capturedRequest, "Request should have been captured")
+
+			// Perform assertions on captured request
+			if tc.expectNoAuthHeader {
+				assert.Empty(t, capturedRequest.Header.Get("Authorization"))
+			} else if len(tc.expectedHeaders) > 0 {
+				authHeaders := capturedRequest.Header["Authorization"]
+				assert.ElementsMatch(t, tc.expectedHeaders, authHeaders)
 			}
 		})
 	}
diff --git a/internal/converter/thrift/jaeger/from_domain_test.go b/internal/converter/thrift/jaeger/from_domain_test.go
deleted file mode 100644
index 8ff22a50..00000000
--- a/internal/converter/thrift/jaeger/from_domain_test.go
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (c) 2019 The Jaeger Authors.
-// Copyright (c) 2017 Uber Technologies, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package jaeger
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/jaegertracing/jaeger-idl/model/v1"
-)
-
-func TestFromDomainOneSpan(t *testing.T) {
-	spanFile := "fixtures/domain_01.json"
-	modelSpans := loadSpans(t, spanFile)
-
-	batchFile := "fixtures/thrift_batch_01.json"
-	jaegerBatch := loadBatch(t, batchFile)
-
-	modelSpan := modelSpans[0]
-	jaegerSpan := FromDomainSpan(modelSpan)
-	newModelSpan := ToDomainSpan(jaegerSpan, jaegerBatch.Process)
-
-	modelSpan.NormalizeTimestamps()
-	newModelSpan.NormalizeTimestamps()
-	assert.Equal(t, modelSpan, newModelSpan)
-}
-
-func TestFromDomain(t *testing.T) {
-	file := "fixtures/domain_03.json"
-	modelSpans := loadSpans(t, file)
-
-	batchFile := "fixtures/thrift_batch_01.json"
-	jaegerBatch := loadBatch(t, batchFile)
-
-	jaegerSpans := FromDomain(modelSpans)
-	newModelSpans := ToDomain(jaegerSpans, jaegerBatch.Process)
-	for i := range newModelSpans {
-		modelSpan := modelSpans[i]
-		newModelSpan := newModelSpans[i]
-		modelSpan.NormalizeTimestamps()
-		newModelSpan.NormalizeTimestamps()
-	}
-	assert.Equal(t, modelSpans, newModelSpans)
-}
-
-func TestKeyValueToTag(t *testing.T) {
-	dToJ := domainToJaegerTransformer{}
-	jaegerTag := dToJ.keyValueToTag(&model.KeyValue{
-		Key:   "some-error",
-		VType: model.ValueType(-1),
-	})
-
-	assert.Equal(t, "Error", jaegerTag.Key)
-	assert.Equal(t, "No suitable tag type found for: -1", *jaegerTag.VStr)
-}
diff --git a/internal/jptrace/utf8_test.go b/internal/jptrace/utf8_test.go
deleted file mode 100644
index 0cf5bf60..00000000
--- a/internal/jptrace/utf8_test.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright (c) 2025 The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package jptrace
-
-import (
-	"testing"
-	"unicode/utf8"
-)
-
-func TestSanitizeUTF8(t *testing.T) {
-	tests := []struct {
-		name  string
-		input string
-		want  string
-	}{
-		{
-			name:  "Valid ASCII",
-			input: "Hello, world!",
-			want:  "Hello, world!",
-		},
-		{
-			name:  "Valid UTF-8 multibyte",
-			input: "こんにちは世界",
-			want:  "こんにちは世界",
-		},
-		{
-			name:  "Valid Emoji",
-			input: "😃🚀🔥",
-			want:  "😃🚀🔥",
-		},
-		{
-			name:  "String with replacement rune",
-			input: string([]byte{0xff, 0xfe, 0xfd}),
-			want:  "���",
-		},
-		{
-			name:  "Mixed valid and invalid",
-			input: "Good\xffMorning",
-			want:  "Good�Morning",
-		},
-		{
-			name:  "Empty string",
-			input: "",
-			want:  "",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			sanitized, err := SanitizeUTF8(tt.input)
-			if err != nil {
-				t.Errorf("SanitizeUTF8 failed: %v", err)
-			}
-			if !utf8.ValidString(sanitized) {
-				t.Errorf("SanitizeUTF8 returned invalid UTF-8 string: %s, want %s", sanitized, tt.want)
-			}
-			if sanitized != tt.want {
-				t.Errorf("SanitizeUTF8 gave not correct output: %s, want %s", sanitized, tt.want)
-			}
-		})
-	}
-}
diff --git a/internal/storage/elasticsearch/config/auth_helper_test.go b/internal/storage/elasticsearch/config/auth_helper_test.go
new file mode 100644
index 00000000..6b2bfc99
--- /dev/null
+++ b/internal/storage/elasticsearch/config/auth_helper_test.go
@@ -0,0 +1,229 @@
+// Copyright (c) 2025 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zaptest/observer"
+
+	"github.com/jaegertracing/jaeger/internal/auth"
+)
+
+// Test the  initBearerAuth function that uses real time
+func TestInitBearerAuth(t *testing.T) {
+	logger := zap.NewNop()
+	tempDir := t.TempDir()
+	bearerFile := filepath.Join(tempDir, "bearer-token")
+	require.NoError(t, os.WriteFile(bearerFile, []byte("test-token"), 0o600))
+
+	tests := []struct {
+		name        string
+		bearerAuth  *BearerTokenAuthentication
+		expectError bool
+		expectNil   bool
+		validate    func(t *testing.T, method *auth.Method)
+	}{
+		{
+			name: "Valid file-based bearer auth",
+			bearerAuth: &BearerTokenAuthentication{
+				FilePath: bearerFile,
+			},
+			expectError: false,
+			expectNil:   false,
+			validate: func(t *testing.T, method *auth.Method) {
+				require.NotNil(t, method)
+				assert.Equal(t, "Bearer", method.Scheme)
+				assert.NotNil(t, method.TokenFn)
+				assert.Equal(t, "test-token", method.TokenFn())
+				assert.Nil(t, method.FromCtx)
+			},
+		},
+		{
+			name: "Valid context-based bearer auth",
+			bearerAuth: &BearerTokenAuthentication{
+				AllowFromContext: true,
+			},
+			expectError: false,
+			expectNil:   false,
+			validate: func(t *testing.T, method *auth.Method) {
+				require.NotNil(t, method)
+				assert.Equal(t, "Bearer", method.Scheme)
+				assert.Nil(t, method.TokenFn)
+				assert.NotNil(t, method.FromCtx)
+			},
+		},
+		{
+			name: "Invalid bearer auth config returns nil",
+			bearerAuth: &BearerTokenAuthentication{
+				FilePath:         "",
+				AllowFromContext: false,
+			},
+			expectError: false,
+			expectNil:   true,
+			validate: func(t *testing.T, method *auth.Method) {
+				assert.Nil(t, method)
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			method, err := initBearerAuth(tc.bearerAuth, logger)
+			if tc.expectError {
+				require.Error(t, err)
+				assert.Nil(t, method)
+			} else {
+				require.NoError(t, err)
+				if tc.expectNil {
+					assert.Nil(t, method)
+				} else {
+					tc.validate(t, method)
+				}
+			}
+		})
+	}
+}
+
+// Test the time-injectable function for advanced scenarios
+func TestInitBearerAuthWithTime(t *testing.T) {
+	logger := zap.NewNop()
+	tempDir := t.TempDir()
+
+	tests := []struct {
+		name               string
+		reloadInterval     time.Duration
+		timeAdvance        time.Duration
+		expectedFinalToken string
+		description        string
+	}{
+		{
+			name:               "Normal reloading behavior",
+			reloadInterval:     50 * time.Millisecond,
+			timeAdvance:        60 * time.Millisecond,
+			expectedFinalToken: "updated-token",
+			description:        "Should return updated token after cache expires",
+		},
+		{
+			name:               "Zero interval disables reloading",
+			reloadInterval:     0,
+			timeAdvance:        24 * time.Minute,
+			expectedFinalToken: "initial-token",
+			description:        "Zero interval should completely disable token reloading",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			tokenFile := filepath.Join(tempDir, "reloadable-token-"+tc.name)
+			require.NoError(t, os.WriteFile(tokenFile, []byte("initial-token"), 0o600))
+
+			currentTime := time.Unix(0, 0)
+			timeFn := func() time.Time { return currentTime }
+
+			bearer := &BearerTokenAuthentication{
+				FilePath:       tokenFile,
+				ReloadInterval: tc.reloadInterval,
+			}
+
+			// Initialize with mock time
+			method, err := initBearerAuthWithTime(bearer, logger, timeFn)
+			require.NoError(t, err)
+			require.NotNil(t, method)
+			require.NotNil(t, method.TokenFn)
+
+			// Initial token
+			token := method.TokenFn()
+			assert.Equal(t, "initial-token", token)
+
+			// Update the file
+			err = os.WriteFile(tokenFile, []byte("updated-token"), 0o600)
+			require.NoError(t, err)
+
+			// Advance time and test
+			currentTime = currentTime.Add(tc.timeAdvance)
+			token = method.TokenFn()
+			assert.Equal(t, tc.expectedFinalToken, token, tc.description)
+		})
+	}
+}
+
+// TestInitBearerAuth_FileErrors tests error handling for file operations in initBearerAuth
+func TestInitBearerAuth_FileErrors(t *testing.T) {
+	core, _ := observer.New(zap.WarnLevel)
+	logger := zap.New(core)
+
+	tests := []struct {
+		name          string
+		bearer        *BearerTokenAuthentication
+		expectedError bool
+		expectNil     bool
+		errorContains string
+	}{
+		{
+			name: "Non-existent file path - returns error",
+			bearer: &BearerTokenAuthentication{
+				FilePath:         "/non/existent/path/token.txt",
+				AllowFromContext: false,
+			},
+			expectedError: true,
+			expectNil:     true,
+			errorContains: "failed to get token from file",
+		},
+		{
+			name: "Non-existent file with context enabled - still returns error",
+			bearer: &BearerTokenAuthentication{
+				FilePath:         "/non/existent/path/token.txt",
+				AllowFromContext: true,
+				ReloadInterval:   5 * time.Second,
+			},
+			expectedError: true,
+			expectNil:     true,
+			errorContains: "failed to get token from file",
+		},
+		{
+			name: "Empty file path with context disabled - returns nil",
+			bearer: &BearerTokenAuthentication{
+				FilePath:         "",
+				AllowFromContext: false,
+			},
+			expectedError: false,
+			expectNil:     true,
+		},
+		{
+			name: "Directory instead of file - returns error",
+			bearer: &BearerTokenAuthentication{
+				FilePath:         "/tmp",
+				AllowFromContext: false,
+			},
+			expectedError: true,
+			expectNil:     true,
+			errorContains: "failed to get token from file",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			method, err := initBearerAuth(tc.bearer, logger)
+			if tc.expectedError {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tc.errorContains)
+				assert.Nil(t, method)
+			} else {
+				require.NoError(t, err)
+				if tc.expectNil {
+					assert.Nil(t, method)
+				} else {
+					assert.NotNil(t, method)
+				}
+			}
+		})
+	}
+}
diff --git a/internal/storage/elasticsearch/config/config_test.go b/internal/storage/elasticsearch/config/config_test.go
index 47986ce1..f0d9fd6e 100644
--- a/internal/storage/elasticsearch/config/config_test.go
+++ b/internal/storage/elasticsearch/config/config_test.go
@@ -610,7 +610,6 @@ func TestTagKeysAsFields(t *testing.T) {
 
 	pwdFile := filepath.Join(t.TempDir(), "pwd")
 	require.NoError(t, os.WriteFile(pwdFile, []byte(pwd1), 0o600))
-
 	tests := []struct {
 		name         string
 		config       *Configuration
@@ -835,7 +834,6 @@ func TestHandleBulkAfterCallback_ErrorMetricsEmitted(t *testing.T) {
 		sm:     sm,
 		logger: logger,
 	}
-
 	bcb.invoke(batchID, fakeRequests, response, assert.AnError)
 
 	mf.AssertCounterMetrics(t,
@@ -878,7 +876,6 @@ func TestHandleBulkAfterCallback_MissingStartTime(t *testing.T) {
 		sm:     sm,
 		logger: logger,
 	}
-
 	bcb.invoke(batchID, fakeRequests, response, assert.AnError)
 
 	mf.AssertCounterMetrics(t,
@@ -899,9 +896,7 @@ func TestHandleBulkAfterCallback_MissingStartTime(t *testing.T) {
 
 func TestGetConfigOptions(t *testing.T) {
 	tmpDir := t.TempDir()
-	apiKeyFile := filepath.Join(tmpDir, "apikey")
 	bearerTokenFile := filepath.Join(tmpDir, "bearertoken")
-	os.WriteFile(apiKeyFile, []byte("test-api-key"), 0o600)
 	os.WriteFile(bearerTokenFile, []byte("file-bearer-token"), 0o600)
 
 	tests := []struct {
@@ -1225,6 +1220,29 @@ func TestGetHTTPRoundTripper(t *testing.T) {
 				assert.True(t, transport.TLSClientConfig.InsecureSkipVerify)
 			},
 		},
+		{
+			name: "Bearer auth not applicable (empty config)",
+			cfg: &Configuration{
+				TLS: configtls.ClientConfig{Insecure: true},
+				Authentication: Authentication{
+					BearerTokenAuthentication: configoptional.Some(BearerTokenAuthentication{
+						FilePath:         "",    // Empty
+						AllowFromContext: false, // Disabled
+					}),
+				},
+			},
+			ctx: context.Background(),
+			validate: func(t *testing.T, rt http.RoundTripper) {
+				assert.NotNil(t, rt)
+				// Should be plain transport since auth is not applicable
+				_, ok := rt.(*auth.RoundTripper)
+				assert.False(t, ok, "Should not be an auth round tripper when config is not applicable")
+
+				transport, ok := rt.(*http.Transport)
+				assert.True(t, ok, "Should be plain http.Transport")
+				assert.True(t, transport.TLSClientConfig.InsecureSkipVerify)
+			},
+		},
 		{
 			name: "Secure mode with bearer token from file",
 			cfg: &Configuration{
@@ -1238,7 +1256,10 @@ func TestGetHTTPRoundTripper(t *testing.T) {
 				assert.NotNil(t, rt)
 				authRT, ok := rt.(*auth.RoundTripper)
 				require.True(t, ok, "Should be an auth round tripper")
-				assert.Equal(t, "file-bearer-token", authRT.StaticToken)
+				require.Len(t, authRT.Auths, 1)
+				assert.Equal(t, "Bearer", authRT.Auths[0].Scheme)
+				assert.NotNil(t, authRT.Auths[0].TokenFn)
+				assert.Equal(t, "file-bearer-token", authRT.Auths[0].TokenFn())
 			},
 		},
 		{
@@ -1254,7 +1275,10 @@ func TestGetHTTPRoundTripper(t *testing.T) {
 				assert.NotNil(t, rt)
 				authRT, ok := rt.(*auth.RoundTripper)
 				require.True(t, ok, "Should be an auth round tripper")
-				assert.True(t, authRT.OverrideFromCtx)
+				require.Len(t, authRT.Auths, 1)
+				assert.Equal(t, "Bearer", authRT.Auths[0].Scheme)
+				assert.NotNil(t, authRT.Auths[0].FromCtx)
+
 				transport, ok := authRT.Transport.(*http.Transport)
 				require.True(t, ok)
 				assert.True(t, transport.TLSClientConfig.InsecureSkipVerify)
@@ -1306,6 +1330,7 @@ func TestLoadTokenFromFile(t *testing.T) {
 		const token = "test-token"
 		tokenFile := filepath.Join(t.TempDir(), "token")
 		require.NoError(t, os.WriteFile(tokenFile, []byte(token), 0o600))
+
 		loadedToken, err := loadTokenFromFile(tokenFile)
 		require.NoError(t, err)
 		assert.Equal(t, token, loadedToken)
@@ -1327,7 +1352,6 @@ func TestBulkCallbackInvoke_NilResponse(t *testing.T) {
 		sm:     sm,
 		logger: logger,
 	}
-
 	bcb.invoke(1, []elastic.BulkableRequest{nil}, nil, assert.AnError)
 
 	mf.AssertCounterMetrics(t,
diff --git a/internal/storage/elasticsearch/query/range_query_test.go b/internal/storage/elasticsearch/query/range_query_test.go
new file mode 100644
index 00000000..8b2055e9
--- /dev/null
+++ b/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)
+}
diff --git a/internal/storage/metricstore/prometheus/metricstore/reader_test.go b/internal/storage/metricstore/prometheus/metricstore/reader_test.go
index 5245a2ea..5d5c59b1 100644
--- a/internal/storage/metricstore/prometheus/metricstore/reader_test.go
+++ b/internal/storage/metricstore/prometheus/metricstore/reader_test.go
@@ -731,19 +731,43 @@ func (s *fakePromServer) getAuth() string {
 
 func TestGetRoundTripperTLSConfig(t *testing.T) {
 	for _, tc := range []struct {
-		name       string
-		tlsEnabled bool
+		name      string
+		tlsConfig configtls.ClientConfig
+		wantErr   bool
 	}{
-		{"tls tlsEnabled", true},
-		{"tls disabled", false},
+		{
+			name: "tls enabled with cert verification",
+			tlsConfig: configtls.ClientConfig{
+				Insecure: false,
+			},
+		},
+		{
+			name: "tls enabled insecure",
+			tlsConfig: configtls.ClientConfig{
+				Insecure: true, // Skip verify
+			},
+		},
+		{
+			name: "invalid tls config",
+			tlsConfig: configtls.ClientConfig{
+				Config: configtls.Config{
+					CAFile: "foo",
+				},
+			},
+			wantErr: true,
+		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			config := &config.Configuration{
 				ConnectTimeout:           9 * time.Millisecond,
-				TLS:                      configtls.ClientConfig{},
+				TLS:                      tc.tlsConfig,
 				TokenOverrideFromContext: true,
 			}
 			rt, err := getHTTPRoundTripper(config)
+			if tc.wantErr {
+				require.Error(t, err)
+				return
+			}
 			require.NoError(t, err)
 
 			server := newFakePromServer(t)
diff --git a/internal/storage/v1/elasticsearch/spanstore/reader_test.go b/internal/storage/v1/elasticsearch/spanstore/reader_test.go
index 713ba8c6..01d82080 100644
--- a/internal/storage/v1/elasticsearch/spanstore/reader_test.go
+++ b/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,8 +1108,8 @@ 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)
 	})
@@ -1118,10 +1117,9 @@ func TestSpanReader_buildDurationQuery(t *testing.T) {
 
 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)
 	})