feat(query): Auto-detect UI base path from browser URL (ADR-009)

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

@@ -45,3 +45,6 @@ jobs:
 
   tailsampling:
     uses: ./.github/workflows/ci-e2e-tailsampling.yml
+
+  ui-reverse-proxy:
+    uses: ./.github/workflows/ci-e2e-ui-reverse-proxy.yml

.github/workflows/ci-e2e-ui-reverse-proxy.yml

@@ -0,0 +1,48 @@
+# Copyright (c) 2026 The Jaeger Authors.
+# SPDX-License-Identifier: Apache-2.0
+
+# E2E integration tests for Jaeger UI served behind a reverse proxy (ADR-009).
+# Validates three use cases in a single job:
+#
+#   UC-1: proxy forwards the URL prefix unchanged to Jaeger
+#         (exercises the existing examples/reverse-proxy/ setup)
+#   UC-2: single Jaeger pod served under two different external prefixes
+#         simultaneously, with the proxy stripping the prefix on one path
+#   UC-3: proxy rewrites an external prefix to a different internal prefix
+#         (the case that motivated ADR-009 / issue #5157)
+
+name: CIT UI Reverse Proxy
+
+on:
+  workflow_call:
+
+# See https://github.com/ossf/scorecard/blob/main/docs/checks.md#token-permissions
+permissions:
+  contents: read
+
+jobs:
+  ui-reverse-proxy:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Harden Runner
+      uses: step-security/harden-runner@a5ad31d6a139d249332a2605b85202e8c0b78450 # v2.19.1
+      with:
+        egress-policy: audit # TODO: change to 'egress-policy: block' after couple of runs
+
+    - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        submodules: true
+
+    - name: Fetch git tags
+      run: git fetch --prune --unshallow --tags
+
+    - uses: ./.github/actions/setup-go
+      with:
+        go-version: 1.26.x
+
+    - name: Setup Node.js version
+      uses: ./.github/actions/setup-node.js
+
+    - name: Run UI reverse-proxy integration tests (UC-1, UC-2, UC-3)
+      run: bash scripts/e2e/ui-reverse-proxy.sh

cmd/jaeger/internal/extension/jaegerquery/internal/static_handler.go

@@ -30,7 +30,6 @@ var (
 	configJsPattern    = regexp.MustCompile(`(?im)^\s*//\s*JAEGER_CONFIG_JS.*\n.*`)
 	versionPattern     = regexp.MustCompile("JAEGER_VERSION *= *DEFAULT_VERSION;")
 	compabilityPattern = regexp.MustCompile("JAEGER_STORAGE_CAPABILITIES *= *DEFAULT_STORAGE_CAPABILITIES;")
-	basePathPattern    = regexp.MustCompile(`<base href="/"`) // Note: tag is not closed
 )
 
 // RegisterStaticHandler adds handler for static assets to the router.
@@ -73,6 +72,10 @@ type loadedConfig struct {
 
 // NewStaticAssetsHandler returns a StaticAssetsHandler
 func NewStaticAssetsHandler(staticAssetsRoot string, options StaticAssetsHandlerOptions) (*StaticAssetsHandler, error) {
+	if bp := options.BasePath; bp != "" && bp != "/" && !strings.HasPrefix(bp, "/") {
+		return nil, fmt.Errorf("invalid base path %q: must start with '/'", bp)
+	}
+
 	assetsFS := ui.GetStaticFiles(options.Logger)
 	if staticAssetsRoot != "" {
 		assetsFS = http.Dir(staticAssetsRoot)
@@ -119,16 +122,8 @@ func (sH *StaticAssetsHandler) loadAndEnrichIndexHTML(open func(string) (http.Fi
 	versionJSON, _ := json.Marshal(version.Get())
 	versionString := fmt.Sprintf("JAEGER_VERSION = %s;", string(versionJSON))
 	indexBytes = versionPattern.ReplaceAll(indexBytes, []byte(versionString))
-	// replace base path
-	if sH.options.BasePath == "" {
-		sH.options.BasePath = "/"
-	}
-	if sH.options.BasePath != "/" {
-		if !strings.HasPrefix(sH.options.BasePath, "/") || strings.HasSuffix(sH.options.BasePath, "/") {
-			return nil, fmt.Errorf("invalid base path '%s'. Must start but not end with a slash '/', e.g. '/jaeger/ui'", sH.options.BasePath)
-		}
-		indexBytes = basePathPattern.ReplaceAll(indexBytes, fmt.Appendf(nil, `<base href="%s/"`, sH.options.BasePath))
-	}
+	// The <base href> is no longer injected here. The UI detects its own mount-point
+	// prefix at page-load time via an inline script in index.html (see ADR-009).
 
 	return indexBytes, nil
 }
@@ -209,8 +204,10 @@ func (sH *StaticAssetsHandler) loggingHandler(handler http.Handler) http.Handler
 // RegisterRoutes registers routes for this handler on the given router.
 func (sH *StaticAssetsHandler) RegisterRoutes(router *http.ServeMux) {
 	basePath := sH.options.BasePath
-	if basePath == "" {
+	if basePath == "" || basePath == "/" {
 		basePath = "/"
+	} else {
+		basePath = strings.TrimRight(basePath, "/")
 	}
 
 	fileServer := http.FileServer(sH.assetsFS)

cmd/jaeger/internal/extension/jaegerquery/internal/static_handler_test.go

@@ -64,15 +64,13 @@ func TestRegisterStaticHandler(t *testing.T) {
 		archiveStorage              bool   // archive storage enabled?
 		metricsStorage              bool   // metrics storage enabled?
 		logAccess                   bool
-		expectedBaseHTML            string // substring to match in the home page
 		UIConfigPath                string // path to UI config
 		expectedUIConfig            string // expected UI config
 		expectedStorageCapabilities string // expected storage capabilities
 	}{
 		{
 			basePath:                    "",
 			baseURL:                     "/",
-			expectedBaseHTML:            `<base href="/"`,
 			archiveStorage:              false,
 			logAccess:                   true,
 			UIConfigPath:                "",
@@ -83,15 +81,13 @@ func TestRegisterStaticHandler(t *testing.T) {
 			basePath:                    "/",
 			baseURL:                     "/",
 			archiveStorage:              false,
-			expectedBaseHTML:            `<base href="/"`,
 			UIConfigPath:                "fixture/ui-config.json",
 			expectedUIConfig:            `JAEGER_CONFIG = {"x":"y"};`,
 			expectedStorageCapabilities: `JAEGER_STORAGE_CAPABILITIES = {"archiveStorage":false,"metricsStorage":false};`,
 		},
 		{
 			basePath:                    "/jaeger",
 			baseURL:                     "/jaeger/",
-			expectedBaseHTML:            `<base href="/jaeger/"`,
 			subroute:                    true,
 			archiveStorage:              true,
 			UIConfigPath:                "fixture/ui-config.js",
@@ -101,7 +97,6 @@ func TestRegisterStaticHandler(t *testing.T) {
 		{
 			basePath:                    "/metrics",
 			baseURL:                     "/metrics/",
-			expectedBaseHTML:            `<base href="/metrics/"`,
 			subroute:                    true,
 			metricsStorage:              true,
 			UIConfigPath:                "fixture/ui-config.js",
@@ -148,7 +143,6 @@ func TestRegisterStaticHandler(t *testing.T) {
 			assert.Contains(t, html, testCase.expectedUIConfig, "actual: %v", html)
 			assert.Contains(t, html, testCase.expectedStorageCapabilities, "actual: %v", html)
 			assert.Contains(t, html, `JAEGER_VERSION = {"gitCommit":"","gitVersion":"dev","buildDate":""};`, "actual: %v", html)
-			assert.Contains(t, html, testCase.expectedBaseHTML, "actual: %v", html)
 
 			asset := httpGet("static/asset.txt")
 			assert.Contains(t, asset, "some asset", "actual: %v", asset)
@@ -169,16 +163,40 @@ func TestNewStaticAssetsHandlerErrors(t *testing.T) {
 		Logger: zap.NewNop(),
 	})
 	require.Error(t, err)
+}
 
-	for _, base := range []string{"x", "x/", "/x/"} {
-		_, err := NewStaticAssetsHandler("fixture", StaticAssetsHandlerOptions{
-			UIConfig: UIConfig{
-				ConfigFile: "fixture/ui-config.json",
-			},
-			BasePath: base,
-			Logger:   zap.NewNop(),
+func TestRegisterRoutesInvalidBasePath(t *testing.T) {
+	for _, basePath := range []string{"no-leading-slash", "no-leading-slash/"} {
+		t.Run(basePath, func(t *testing.T) {
+			_, err := NewStaticAssetsHandler("fixture", StaticAssetsHandlerOptions{
+				BasePath: basePath,
+				Logger:   zap.NewNop(),
+			})
+			require.Error(t, err)
+			assert.Contains(t, err.Error(), "must start with '/'")
+		})
+	}
+}
+
+func TestRegisterRoutesTrailingSlashNormalization(t *testing.T) {
+	for _, basePath := range []string{"/jaeger/", "/jaeger//", "/jaeger///"} {
+		t.Run(basePath, func(t *testing.T) {
+			h, err := NewStaticAssetsHandler("fixture", StaticAssetsHandlerOptions{
+				BasePath: basePath,
+				Logger:   zap.NewNop(),
+			})
+			require.NoError(t, err)
+			defer h.Close()
+			mux := http.NewServeMux()
+			h.RegisterRoutes(mux)
+			// Verify routes are registered under /jaeger/, not /jaeger//
+			srv := httptest.NewServer(mux)
+			defer srv.Close()
+			resp, err := http.Get(srv.URL + "/jaeger/static/")
+			require.NoError(t, err)
+			resp.Body.Close()
+			assert.NotEqual(t, http.StatusNotFound, resp.StatusCode, "static route should be reachable at /jaeger/static/")
 		})
-		assert.ErrorContainsf(t, err, "invalid base path", "basePath=%s", base)
 	}
 }