Merge branch 'main' into feat/update_hosts_list_error_messaging

ee/query-service/app/api/api.go

@@ -2,9 +2,11 @@ package api
 
 import (
 	"net/http"
+	"net/http/httputil"
 	"time"
 
 	"github.com/SigNoz/signoz/ee/licensing/httplicensing"
+	"github.com/SigNoz/signoz/ee/query-service/integrations/gateway"
 	"github.com/SigNoz/signoz/ee/query-service/usage"
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/global"
@@ -29,6 +31,7 @@ type APIHandlerOptions struct {
 	IntegrationsController        *integrations.Controller
 	CloudIntegrationsController   *cloudintegrations.Controller
 	LogsParsingPipelineController *logparsingpipeline.LogParsingPipelineController
+	Gateway                       *httputil.ReverseProxy
 	GatewayUrl                    string
 	// Querier Influx Interval
 	FluxInterval time.Duration
@@ -74,6 +77,10 @@ func (ah *APIHandler) UM() *usage.Manager {
 	return ah.opts.UsageManager
 }
 
+func (ah *APIHandler) Gateway() *httputil.ReverseProxy {
+	return ah.opts.Gateway
+}
+
 // RegisterRoutes registers routes for this handler on the given router
 func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	// note: add ee override methods first
@@ -96,6 +103,9 @@ func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	// v4
 	router.HandleFunc("/api/v4/query_range", am.ViewAccess(ah.queryRangeV4)).Methods(http.MethodPost)
 
+	// Gateway
+	router.PathPrefix(gateway.RoutePrefix).HandlerFunc(am.EditAccess(ah.ServeGatewayHTTP))
+
 	ah.APIHandler.RegisterRoutes(router, am)
 
 }

ee/query-service/app/api/gateway.go

@@ -0,0 +1,58 @@
+package api
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/SigNoz/signoz/ee/query-service/integrations/gateway"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+func (ah *APIHandler) ServeGatewayHTTP(rw http.ResponseWriter, req *http.Request) {
+	ctx := req.Context()
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "orgId is invalid"))
+		return
+	}
+
+	validPath := false
+	for _, allowedPrefix := range gateway.AllowedPrefix {
+		if strings.HasPrefix(req.URL.Path, gateway.RoutePrefix+allowedPrefix) {
+			validPath = true
+			break
+		}
+	}
+
+	if !validPath {
+		rw.WriteHeader(http.StatusNotFound)
+		return
+	}
+
+	license, err := ah.Signoz.Licensing.GetActive(ctx, orgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	//Create headers
+	var licenseKey string
+	if license != nil {
+		licenseKey = license.Key
+	}
+
+	req.Header.Set("X-Signoz-Cloud-Api-Key", licenseKey)
+	req.Header.Set("X-Consumer-Username", "lid:00000000-0000-0000-0000-000000000000")
+	req.Header.Set("X-Consumer-Groups", "ns:default")
+
+	ah.Gateway().ServeHTTP(rw, req)
+}

ee/query-service/app/server.go

@@ -19,6 +19,7 @@ import (
 	"github.com/gorilla/handlers"
 
 	"github.com/SigNoz/signoz/ee/query-service/app/api"
+	"github.com/SigNoz/signoz/ee/query-service/integrations/gateway"
 	"github.com/SigNoz/signoz/ee/query-service/rules"
 	"github.com/SigNoz/signoz/ee/query-service/usage"
 	"github.com/SigNoz/signoz/pkg/alertmanager"
@@ -71,6 +72,11 @@ type Server struct {
 
 // NewServer creates and initializes Server
 func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
+	gatewayProxy, err := gateway.NewProxy(config.Gateway.URL.String(), gateway.RoutePrefix)
+	if err != nil {
+		return nil, err
+	}
+
 	cacheForTraceDetail, err := memorycache.New(context.TODO(), signoz.Instrumentation.ToProviderSettings(), cache.Config{
 		Provider: "memory",
 		Memory: cache.Memory{
@@ -164,6 +170,7 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 		CloudIntegrationsController:   cloudIntegrationsController,
 		LogsParsingPipelineController: logParsingPipelineController,
 		FluxInterval:                  config.Querier.FluxInterval,
+		Gateway:                       gatewayProxy,
 		GatewayUrl:                    config.Gateway.URL.String(),
 		GlobalConfig:                  config.Global,
 	}

ee/query-service/integrations/gateway/noop.go

@@ -0,0 +1,9 @@
+package gateway
+
+import (
+	"net/http/httputil"
+)
+
+func NewNoopProxy() (*httputil.ReverseProxy, error) {
+	return &httputil.ReverseProxy{}, nil
+}

ee/query-service/integrations/gateway/proxy.go

@@ -0,0 +1,66 @@
+package gateway
+
+import (
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"path"
+	"strings"
+)
+
+var (
+	RoutePrefix   string   = "/api/gateway"
+	AllowedPrefix []string = []string{"/v1/workspaces/me", "/v2/profiles/me", "/v2/deployments/me"}
+)
+
+type proxy struct {
+	url       *url.URL
+	stripPath string
+}
+
+func NewProxy(u string, stripPath string) (*httputil.ReverseProxy, error) {
+	url, err := url.Parse(u)
+	if err != nil {
+		return nil, err
+	}
+
+	proxy := &proxy{url: url, stripPath: stripPath}
+
+	return &httputil.ReverseProxy{
+		Rewrite:        proxy.rewrite,
+		ModifyResponse: proxy.modifyResponse,
+		ErrorHandler:   proxy.errorHandler,
+	}, nil
+}
+
+func (p *proxy) rewrite(pr *httputil.ProxyRequest) {
+	pr.SetURL(p.url)
+	pr.SetXForwarded()
+	pr.Out.URL.Path = cleanPath(strings.ReplaceAll(pr.Out.URL.Path, p.stripPath, ""))
+}
+
+func (p *proxy) modifyResponse(res *http.Response) error {
+	return nil
+}
+
+func (p *proxy) errorHandler(rw http.ResponseWriter, req *http.Request, err error) {
+	rw.WriteHeader(http.StatusBadGateway)
+}
+
+func cleanPath(p string) string {
+	if p == "" {
+		return "/"
+	}
+	if p[0] != '/' {
+		p = "/" + p
+	}
+	np := path.Clean(p)
+	if p[len(p)-1] == '/' && np != "/" {
+		if len(p) == len(np)+1 && strings.HasPrefix(p, np) {
+			np = p
+		} else {
+			np += "/"
+		}
+	}
+	return np
+}

ee/query-service/integrations/gateway/proxy_test.go

@@ -0,0 +1,61 @@
+package gateway
+
+import (
+	"context"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestProxyRewrite(t *testing.T) {
+	testCases := []struct {
+		name      string
+		url       *url.URL
+		stripPath string
+		in        *url.URL
+		expected  *url.URL
+	}{
+		{
+			name:      "SamePathAdded",
+			url:       &url.URL{Scheme: "http", Host: "backend", Path: "/path1"},
+			stripPath: "/strip",
+			in:        &url.URL{Scheme: "http", Host: "localhost", Path: "/strip/path1"},
+			expected:  &url.URL{Scheme: "http", Host: "backend", Path: "/path1/path1"},
+		},
+		{
+			name:      "NoStripPathInput",
+			url:       &url.URL{Scheme: "http", Host: "backend"},
+			stripPath: "",
+			in:        &url.URL{Scheme: "http", Host: "localhost", Path: "/strip/path1"},
+			expected:  &url.URL{Scheme: "http", Host: "backend", Path: "/strip/path1"},
+		},
+		{
+			name:      "NoStripPathPresentInReq",
+			url:       &url.URL{Scheme: "http", Host: "backend"},
+			stripPath: "/not-found",
+			in:        &url.URL{Scheme: "http", Host: "localhost", Path: "/strip/path1"},
+			expected:  &url.URL{Scheme: "http", Host: "backend", Path: "/strip/path1"},
+		},
+	}
+
+	for _, tc := range testCases {
+		proxy, err := NewProxy(tc.url.String(), tc.stripPath)
+		require.NoError(t, err)
+		inReq, err := http.NewRequest(http.MethodGet, tc.in.String(), nil)
+		require.NoError(t, err)
+		proxyReq := &httputil.ProxyRequest{
+			In:  inReq,
+			Out: inReq.Clone(context.Background()),
+		}
+		proxy.Rewrite(proxyReq)
+
+		assert.Equal(t, tc.expected.Host, proxyReq.Out.URL.Host)
+		assert.Equal(t, tc.expected.Scheme, proxyReq.Out.URL.Scheme)
+		assert.Equal(t, tc.expected.Path, proxyReq.Out.URL.Path)
+		assert.Equal(t, tc.expected.Query(), proxyReq.Out.URL.Query())
+	}
+}

frontend/src/api/IngestionKeys/createIngestionKey.ts

@@ -0,0 +1,29 @@
+import { GatewayApiV1Instance } from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import {
+	CreateIngestionKeyProps,
+	IngestionKeyProps,
+} from 'types/api/ingestionKeys/types';
+
+const createIngestionKey = async (
+	props: CreateIngestionKeyProps,
+): Promise<SuccessResponse<IngestionKeyProps> | ErrorResponse> => {
+	try {
+		const response = await GatewayApiV1Instance.post('/workspaces/me/keys', {
+			...props,
+		});
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};
+
+export default createIngestionKey;

frontend/src/api/IngestionKeys/deleteIngestionKey.ts

@@ -0,0 +1,26 @@
+import { GatewayApiV1Instance } from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { AllIngestionKeyProps } from 'types/api/ingestionKeys/types';
+
+const deleteIngestionKey = async (
+	id: string,
+): Promise<SuccessResponse<AllIngestionKeyProps> | ErrorResponse> => {
+	try {
+		const response = await GatewayApiV1Instance.delete(
+			`/workspaces/me/keys/${id}`,
+		);
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};
+
+export default deleteIngestionKey;

frontend/src/api/IngestionKeys/getAllIngestionKeys.ts

@@ -0,0 +1,21 @@
+import { GatewayApiV1Instance } from 'api';
+import { AxiosResponse } from 'axios';
+import {
+	AllIngestionKeyProps,
+	GetIngestionKeyProps,
+} from 'types/api/ingestionKeys/types';
+
+export const getAllIngestionKeys = (
+	props: GetIngestionKeyProps,
+): Promise<AxiosResponse<AllIngestionKeyProps>> => {
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	const { search, per_page, page } = props;
+
+	const BASE_URL = '/workspaces/me/keys';
+	const URL_QUERY_PARAMS =
+		search && search.length > 0
+			? `/search?name=${search}&page=1&per_page=100`
+			: `?page=${page}&per_page=${per_page}`;
+
+	return GatewayApiV1Instance.get(`${BASE_URL}${URL_QUERY_PARAMS}`);
+};

frontend/src/api/IngestionKeys/limits/createLimitsForKey.ts

@@ -0,0 +1,65 @@
+/* eslint-disable @typescript-eslint/no-throw-literal */
+import { GatewayApiV1Instance } from 'api';
+import axios from 'axios';
+import {
+	AddLimitProps,
+	LimitSuccessProps,
+} from 'types/api/ingestionKeys/limits/types';
+
+interface SuccessResponse<T> {
+	statusCode: number;
+	error: null;
+	message: string;
+	payload: T;
+}
+
+interface ErrorResponse {
+	statusCode: number;
+	error: string;
+	message: string;
+	payload: null;
+}
+
+const createLimitForIngestionKey = async (
+	props: AddLimitProps,
+): Promise<SuccessResponse<LimitSuccessProps> | ErrorResponse> => {
+	try {
+		const response = await GatewayApiV1Instance.post(
+			`/workspaces/me/keys/${props.keyID}/limits`,
+			{
+				...props,
+			},
+		);
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data.data,
+		};
+	} catch (error) {
+		if (axios.isAxiosError(error)) {
+			// Axios error
+			const errResponse: ErrorResponse = {
+				statusCode: error.response?.status || 500,
+				error: error.response?.data?.error,
+				message: error.response?.data?.status || 'An error occurred',
+				payload: null,
+			};
+
+			throw errResponse;
+		} else {
+			// Non-Axios error
+			const errResponse: ErrorResponse = {
+				statusCode: 500,
+				error: 'Unknown error',
+				message: 'An unknown error occurred',
+				payload: null,
+			};
+
+			throw errResponse;
+		}
+	}
+};
+
+export default createLimitForIngestionKey;

frontend/src/api/IngestionKeys/limits/deleteLimitsForIngestionKey.ts

@@ -0,0 +1,26 @@
+import { GatewayApiV1Instance } from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { AllIngestionKeyProps } from 'types/api/ingestionKeys/types';
+
+const deleteLimitsForIngestionKey = async (
+	id: string,
+): Promise<SuccessResponse<AllIngestionKeyProps> | ErrorResponse> => {
+	try {
+		const response = await GatewayApiV1Instance.delete(
+			`/workspaces/me/limits/${id}`,
+		);
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};
+
+export default deleteLimitsForIngestionKey;

frontend/src/api/IngestionKeys/limits/updateLimitsForIngestionKey.ts

@@ -0,0 +1,65 @@
+/* eslint-disable @typescript-eslint/no-throw-literal */
+import { GatewayApiV1Instance } from 'api';
+import axios from 'axios';
+import {
+	LimitSuccessProps,
+	UpdateLimitProps,
+} from 'types/api/ingestionKeys/limits/types';
+
+interface SuccessResponse<T> {
+	statusCode: number;
+	error: null;
+	message: string;
+	payload: T;
+}
+
+interface ErrorResponse {
+	statusCode: number;
+	error: string;
+	message: string;
+	payload: null;
+}
+
+const updateLimitForIngestionKey = async (
+	props: UpdateLimitProps,
+): Promise<SuccessResponse<LimitSuccessProps> | ErrorResponse> => {
+	try {
+		const response = await GatewayApiV1Instance.patch(
+			`/workspaces/me/limits/${props.limitID}`,
+			{
+				config: props.config,
+			},
+		);
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data.data,
+		};
+	} catch (error) {
+		if (axios.isAxiosError(error)) {
+			// Axios error
+			const errResponse: ErrorResponse = {
+				statusCode: error.response?.status || 500,
+				error: error.response?.data?.error,
+				message: error.response?.data?.status || 'An error occurred',
+				payload: null,
+			};
+
+			throw errResponse;
+		} else {
+			// Non-Axios error
+			const errResponse: ErrorResponse = {
+				statusCode: 500,
+				error: 'Unknown error',
+				message: 'An unknown error occurred',
+				payload: null,
+			};
+
+			throw errResponse;
+		}
+	}
+};
+
+export default updateLimitForIngestionKey;

frontend/src/api/IngestionKeys/updateIngestionKey.ts

@@ -0,0 +1,32 @@
+import { GatewayApiV1Instance } from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import {
+	IngestionKeysPayloadProps,
+	UpdateIngestionKeyProps,
+} from 'types/api/ingestionKeys/types';
+
+const updateIngestionKey = async (
+	props: UpdateIngestionKeyProps,
+): Promise<SuccessResponse<IngestionKeysPayloadProps> | ErrorResponse> => {
+	try {
+		const response = await GatewayApiV1Instance.patch(
+			`/workspaces/me/keys/${props.id}`,
+			{
+				...props.data,
+			},
+		);
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};
+
+export default updateIngestionKey;

frontend/src/api/apiV1.ts

@@ -4,6 +4,8 @@ export const apiV2 = '/api/v2/';
 export const apiV3 = '/api/v3/';
 export const apiV4 = '/api/v4/';
 export const apiV5 = '/api/v5/';
+export const gatewayApiV1 = '/api/gateway/v1/';
+export const gatewayApiV2 = '/api/gateway/v2/';
 export const apiAlertManager = '/api/alertmanager/';
 
 export default apiV1;

frontend/src/api/customDomain/getDeploymentsData.ts

@@ -0,0 +1,7 @@
+import { GatewayApiV2Instance as axios } from 'api';
+import { AxiosResponse } from 'axios';
+import { DeploymentsDataProps } from 'types/api/customDomain/types';
+
+export const getDeploymentsData = (): Promise<
+	AxiosResponse<DeploymentsDataProps>
+> => axios.get(`/deployments/me`);

frontend/src/api/customDomain/updateSubDomain.ts

@@ -0,0 +1,16 @@
+import { GatewayApiV2Instance as axios } from 'api';
+import { AxiosError } from 'axios';
+import { SuccessResponse } from 'types/api';
+import {
+	PayloadProps,
+	UpdateCustomDomainProps,
+} from 'types/api/customDomain/types';
+
+const updateSubDomainAPI = async (
+	props: UpdateCustomDomainProps,
+): Promise<SuccessResponse<PayloadProps> | AxiosError> =>
+	axios.put(`/deployments/me/host`, {
+		...props.data,
+	});
+
+export default updateSubDomainAPI;

frontend/src/api/index.ts

@@ -15,7 +15,15 @@ import { Events } from 'constants/events';
 import { LOCALSTORAGE } from 'constants/localStorage';
 import { eventEmitter } from 'utils/getEventEmitter';
 
-import apiV1, { apiAlertManager, apiV2, apiV3, apiV4, apiV5 } from './apiV1';
+import apiV1, {
+	apiAlertManager,
+	apiV2,
+	apiV3,
+	apiV4,
+	apiV5,
+	gatewayApiV1,
+	gatewayApiV2,
+} from './apiV1';
 import { Logout } from './utils';
 
 const RESPONSE_TIMEOUT_THRESHOLD = 5000; // 5 seconds
@@ -203,6 +211,24 @@ LogEventAxiosInstance.interceptors.response.use(
 LogEventAxiosInstance.interceptors.request.use(interceptorsRequestResponse);
 //
 
+// gateway Api V1
+export const GatewayApiV1Instance = axios.create({
+	baseURL: `${ENVIRONMENT.baseURL}${gatewayApiV1}`,
+});
+
+GatewayApiV1Instance.interceptors.response.use(
+	interceptorsResponse,
+	interceptorRejected,
+);
+
+GatewayApiV1Instance.interceptors.request.use(interceptorsRequestResponse);
+//
+
+// gateway Api V2
+export const GatewayApiV2Instance = axios.create({
+	baseURL: `${ENVIRONMENT.baseURL}${gatewayApiV2}`,
+});
+
 // generated API Instance
 export const GeneratedAPIInstance = axios.create({
 	baseURL: ENVIRONMENT.baseURL,
@@ -214,6 +240,14 @@ GeneratedAPIInstance.interceptors.response.use(
 	interceptorRejected,
 );
 
+GatewayApiV2Instance.interceptors.response.use(
+	interceptorsResponse,
+	interceptorRejected,
+);
+
+GatewayApiV2Instance.interceptors.request.use(interceptorsRequestResponse);
+//
+
 AxiosAlertManagerInstance.interceptors.response.use(
 	interceptorsResponse,
 	interceptorRejected,

frontend/src/api/infraMonitoring/getHostLists.ts

@@ -50,6 +50,7 @@ export interface HostListResponse {
 		total: number;
 		sentAnyHostMetricsData: boolean;
 		isSendingK8SAgentMetrics: boolean;
+		endTimeBeforeRetention: boolean;
 	};
 }
 

frontend/src/api/onboarding/updateProfile.ts

@@ -0,0 +1,20 @@
+import { GatewayApiV2Instance } from 'api';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { UpdateProfileProps } from 'types/api/onboarding/types';
+
+const updateProfile = async (
+	props: UpdateProfileProps,
+): Promise<SuccessResponse<UpdateProfileProps> | ErrorResponse> => {
+	const response = await GatewayApiV2Instance.put('/profiles/me', {
+		...props,
+	});
+
+	return {
+		statusCode: 200,
+		error: null,
+		message: response.data.status,
+		payload: response.data.data,
+	};
+};
+
+export default updateProfile;

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/AllEndPoints.tsx

@@ -202,7 +202,7 @@ function AllEndPoints({
 
 	const onRowClick = useCallback(
 		(props: any): void => {
-			setSelectedEndPointName(props[SPAN_ATTRIBUTES.HTTP_URL] as string);
+			setSelectedEndPointName(props[SPAN_ATTRIBUTES.URL_PATH] as string);
 			setSelectedView(VIEWS.ENDPOINT_STATS);
 			const initialItems = [
 				...(filters?.items || []),
@@ -213,7 +213,7 @@ function AllEndPoints({
 				op: 'AND',
 			});
 			setParams({
-				selectedEndPointName: props[SPAN_ATTRIBUTES.HTTP_URL] as string,
+				selectedEndPointName: props[SPAN_ATTRIBUTES.URL_PATH] as string,
 				selectedView: VIEWS.ENDPOINT_STATS,
 				endPointDetailsLocalFilters: {
 					items: initialItems,

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/EndPointDetails.tsx

@@ -33,7 +33,7 @@ import { SPAN_ATTRIBUTES } from './constants';
 
 const httpUrlKey = {
 	dataType: DataTypes.String,
-	key: SPAN_ATTRIBUTES.HTTP_URL,
+	key: SPAN_ATTRIBUTES.URL_PATH,
 	type: 'tag',
 };
 
@@ -93,7 +93,7 @@ function EndPointDetails({
 				return currentFilters; // No change needed, prevents loop
 			}
 
-			// Rebuild filters: Keep non-http_url filters and add/update http_url filter based on prop
+			// Rebuild filters: Keep non-http.url filters and add/update http.url filter based on prop
 			const otherFilters = currentFilters?.items?.filter(
 				(item) => item.key?.key !== httpUrlKey.key,
 			);
@@ -125,7 +125,7 @@ function EndPointDetails({
 		(newFilters: IBuilderQuery['filters']): void => {
 			// 1. Update local filters state immediately
 			setFilters(newFilters);
-			// Filter out http_url filter before saving to params
+			// Filter out http.url filter before saving to params
 			const filteredNewFilters = {
 				op: 'AND',
 				items:
@@ -299,6 +299,7 @@ function EndPointDetails({
 					endPointStatusCodeLatencyBarChartsDataQuery
 				}
 				domainName={domainName}
+				endPointName={endPointName}
 				filters={filters}
 				timeRange={timeRange}
 				onDragSelect={onDragSelect}

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/TopErrors.tsx

@@ -56,15 +56,15 @@ function TopErrors({
 				{
 					items: endPointName
 						? [
-								// Remove any existing http_url filters from initialFilters to avoid duplicates
+								// Remove any existing http.url filters from initialFilters to avoid duplicates
 								...(initialFilters?.items?.filter(
-									(item) => item.key?.key !== SPAN_ATTRIBUTES.HTTP_URL,
+									(item) => item.key?.key !== SPAN_ATTRIBUTES.URL_PATH,
 								) || []),
 								{
 									id: '92b8a1c1',
 									key: {
 										dataType: DataTypes.String,
-										key: SPAN_ATTRIBUTES.HTTP_URL,
+										key: SPAN_ATTRIBUTES.URL_PATH,
 										type: 'tag',
 									},
 									op: '=',

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/components/DomainMetrics.test.tsx

@@ -9,7 +9,6 @@ import { ENTITY_VERSION_V5 } from 'constants/app';
 import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 
-import { SPAN_ATTRIBUTES } from '../constants';
 import DomainMetrics from './DomainMetrics';
 
 // Mock the API call
@@ -127,9 +126,11 @@ describe('DomainMetrics - V5 Query Payload Tests', () => {
 				'count()',
 			);
 			// Verify exact domain filter expression structure
-			expect(queryA.filter.expression).toContain("http_host = '0.0.0.0'");
 			expect(queryA.filter.expression).toContain(
-				`${SPAN_ATTRIBUTES.HTTP_URL} EXISTS`,
+				"(net.peer.name = '0.0.0.0' OR server.address = '0.0.0.0')",
+			);
+			expect(queryA.filter.expression).toContain(
+				'url.full EXISTS OR http.url EXISTS',
 			);
 
 			// Verify Query B - p99 latency
@@ -141,13 +142,17 @@ describe('DomainMetrics - V5 Query Payload Tests', () => {
 				'p99(duration_nano)',
 			);
 			// Verify exact domain filter expression structure
-			expect(queryB.filter.expression).toContain("http_host = '0.0.0.0'");
+			expect(queryB.filter.expression).toContain(
+				"(net.peer.name = '0.0.0.0' OR server.address = '0.0.0.0')",
+			);
 
 			// Verify Query C - error count (disabled)
 			const queryC = queryData.find((q: any) => q.queryName === 'C');
 			expect(queryC).toBeDefined();
 			expect(queryC.disabled).toBe(true);
-			expect(queryC.filter.expression).toContain("http_host = '0.0.0.0'");
+			expect(queryC.filter.expression).toContain(
+				"(net.peer.name = '0.0.0.0' OR server.address = '0.0.0.0')",
+			);
 			expect(queryC.aggregations?.[0]).toBeDefined();
 			expect((queryC.aggregations?.[0] as TraceAggregation)?.expression).toBe(
 				'count()',
@@ -164,7 +169,9 @@ describe('DomainMetrics - V5 Query Payload Tests', () => {
 				'max(timestamp)',
 			);
 			// Verify exact domain filter expression structure
-			expect(queryD.filter.expression).toContain("http_host = '0.0.0.0'");
+			expect(queryD.filter.expression).toContain(
+				"(net.peer.name = '0.0.0.0' OR server.address = '0.0.0.0')",
+			);
 
 			// Verify Formula F1 - error rate calculation
 			const formulas = payload.query.builder.queryFormulas;

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/components/EndPointMetrics.test.tsx

@@ -153,7 +153,7 @@ describe('EndPointMetrics - V5 Query Payload Tests', () => {
 				// Verify exact domain filter expression structure
 				if (queryA.filter) {
 					expect(queryA.filter.expression).toContain(
-						`http_host = 'api.example.com'`,
+						"(net.peer.name = 'api.example.com' OR server.address = 'api.example.com')",
 					);
 					expect(queryA.filter.expression).toContain("kind_string = 'Client'");
 				}
@@ -171,7 +171,7 @@ describe('EndPointMetrics - V5 Query Payload Tests', () => {
 				// Verify exact domain filter expression structure
 				if (queryB.filter) {
 					expect(queryB.filter.expression).toContain(
-						`http_host = 'api.example.com'`,
+						"(net.peer.name = 'api.example.com' OR server.address = 'api.example.com')",
 					);
 					expect(queryB.filter.expression).toContain("kind_string = 'Client'");
 				}
@@ -185,7 +185,7 @@ describe('EndPointMetrics - V5 Query Payload Tests', () => {
 				expect(queryC.aggregateOperator).toBe('count');
 				if (queryC.filter) {
 					expect(queryC.filter.expression).toContain(
-						`http_host = 'api.example.com'`,
+						"(net.peer.name = 'api.example.com' OR server.address = 'api.example.com')",
 					);
 					expect(queryC.filter.expression).toContain("kind_string = 'Client'");
 					expect(queryC.filter.expression).toContain('has_error = true');
@@ -204,7 +204,7 @@ describe('EndPointMetrics - V5 Query Payload Tests', () => {
 				// Verify exact domain filter expression structure
 				if (queryD.filter) {
 					expect(queryD.filter.expression).toContain(
-						`http_host = 'api.example.com'`,
+						"(net.peer.name = 'api.example.com' OR server.address = 'api.example.com')",
 					);
 					expect(queryD.filter.expression).toContain("kind_string = 'Client'");
 				}
@@ -221,7 +221,7 @@ describe('EndPointMetrics - V5 Query Payload Tests', () => {
 				}
 				if (queryE.filter) {
 					expect(queryE.filter.expression).toContain(
-						`http_host = 'api.example.com'`,
+						"(net.peer.name = 'api.example.com' OR server.address = 'api.example.com')",
 					);
 					expect(queryE.filter.expression).toContain("kind_string = 'Client'");
 				}
@@ -291,7 +291,7 @@ describe('EndPointMetrics - V5 Query Payload Tests', () => {
 					expect(query.filter.expression).toContain('staging');
 					// Also verify domain filter is still present
 					expect(query.filter.expression).toContain(
-						"http_host = 'api.internal.com'",
+						"(net.peer.name = 'api.internal.com' OR server.address = 'api.internal.com')",
 					);
 					// Verify client kind filter is present
 					expect(query.filter.expression).toContain("kind_string = 'Client'");

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/components/StatusCodeBarCharts.tsx

@@ -34,6 +34,7 @@ function StatusCodeBarCharts({
 	endPointStatusCodeBarChartsDataQuery,
 	endPointStatusCodeLatencyBarChartsDataQuery,
 	domainName,
+	endPointName,
 	filters,
 	timeRange,
 	onDragSelect,
@@ -47,6 +48,7 @@ function StatusCodeBarCharts({
 		unknown
 	>;
 	domainName: string;
+	endPointName: string;
 	filters: IBuilderQuery['filters'];
 	timeRange: {
 		startTime: number;
@@ -142,11 +144,11 @@ function StatusCodeBarCharts({
 
 	const widget = useMemo<Widgets>(
 		() =>
-			getStatusCodeBarChartWidgetData(domainName, {
+			getStatusCodeBarChartWidgetData(domainName, endPointName, {
 				items: [...(filters?.items || [])],
 				op: filters?.op || 'AND',
 			}),
-		[domainName, filters],
+		[domainName, endPointName, filters],
 	);
 
 	const graphClickHandler = useCallback(
@@ -164,7 +166,6 @@ function StatusCodeBarCharts({
 				xValue,
 				TWO_AND_HALF_MINUTES_IN_MILLISECONDS,
 			);
-
 			handleGraphClick({
 				xValue,
 				yValue,

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/constants.ts

@@ -12,7 +12,7 @@ export const VIEW_TYPES = {
 
 // Span attribute keys - these are the source of truth for all attribute keys
 export const SPAN_ATTRIBUTES = {
-	HTTP_URL: 'http_url',
+	URL_PATH: 'http.url',
 	RESPONSE_STATUS_CODE: 'response_status_code',
 	SERVER_NAME: 'http_host',
 	SERVER_PORT: 'net.peer.port',

frontend/src/container/ApiMonitoring/__tests__/APIMonitoringUtils.test.tsx

@@ -280,7 +280,7 @@ describe('API Monitoring Utils', () => {
 			const endpointFilter = result?.items?.find(
 				(item) =>
 					item.key &&
-					item.key.key === SPAN_ATTRIBUTES.HTTP_URL &&
+					item.key.key === SPAN_ATTRIBUTES.URL_PATH &&
 					item.value === endPointName,
 			);
 			expect(endpointFilter).toBeDefined();
@@ -344,12 +344,13 @@ describe('API Monitoring Utils', () => {
 	describe('getFormattedEndPointDropDownData', () => {
 		it('should format endpoint dropdown data correctly', () => {
 			// Arrange
-			const URL_PATH_KEY = SPAN_ATTRIBUTES.HTTP_URL;
+			const URL_PATH_KEY = SPAN_ATTRIBUTES.URL_PATH;
 			const mockData = [
 				{
 					data: {
 						// eslint-disable-next-line sonarjs/no-duplicate-string
 						[URL_PATH_KEY]: '/api/users',
+						'url.full': 'http://example.com/api/users',
 						A: 150, // count or other metric
 					},
 				},
@@ -357,6 +358,7 @@ describe('API Monitoring Utils', () => {
 					data: {
 						// eslint-disable-next-line sonarjs/no-duplicate-string
 						[URL_PATH_KEY]: '/api/orders',
+						'url.full': 'http://example.com/api/orders',
 						A: 75,
 					},
 				},
@@ -404,7 +406,7 @@ describe('API Monitoring Utils', () => {
 
 		it('should handle items without URL path', () => {
 			// Arrange
-			const URL_PATH_KEY = SPAN_ATTRIBUTES.HTTP_URL;
+			const URL_PATH_KEY = SPAN_ATTRIBUTES.URL_PATH;
 			type MockDataType = {
 				data: {
 					[key: string]: string | number;
@@ -710,11 +712,13 @@ describe('API Monitoring Utils', () => {
 		it('should generate widget configuration for status code bar chart', () => {
 			// Arrange
 			const domainName = 'test-domain';
+			const endPointName = '/api/test';
 			const filters = { items: [], op: 'AND' };
 
 			// Act
 			const result = getStatusCodeBarChartWidgetData(
 				domainName,
+				endPointName,
 				filters as IBuilderQuery['filters'],
 			);
 
@@ -737,11 +741,21 @@ describe('API Monitoring Utils', () => {
 			if (domainFilter) {
 				expect(domainFilter.value).toBe(domainName);
 			}
+
+			// Should have endpoint filter if provided
+			const endpointFilter = queryData.filters?.items?.find(
+				(item) => item.key && item.key.key === SPAN_ATTRIBUTES.URL_PATH,
+			);
+			expect(endpointFilter).toBeDefined();
+			if (endpointFilter) {
+				expect(endpointFilter.value).toBe(endPointName);
+			}
 		});
 
 		it('should include custom filters in the widget configuration', () => {
 			// Arrange
 			const domainName = 'test-domain';
+			const endPointName = '/api/test';
 			const customFilter = {
 				id: 'custom-filter',
 				key: {
@@ -757,6 +771,7 @@ describe('API Monitoring Utils', () => {
 			// Act
 			const result = getStatusCodeBarChartWidgetData(
 				domainName,
+				endPointName,
 				filters as IBuilderQuery['filters'],
 			);
 

frontend/src/container/ApiMonitoring/__tests__/AllEndPoints.test.tsx

@@ -25,7 +25,7 @@ jest.mock('container/GridCardLayout/GridCard', () => ({
 				type="button"
 				data-testid="row-click-button"
 				onClick={(): void =>
-					customOnRowClick({ [SPAN_ATTRIBUTES.HTTP_URL]: '/api/test' })
+					customOnRowClick({ [SPAN_ATTRIBUTES.URL_PATH]: '/api/test' })
 				}
 			>
 				Click Row

frontend/src/container/ApiMonitoring/__tests__/AllEndpointsWidgetV5Migration.test.tsx

@@ -6,10 +6,10 @@
  * These tests validate the migration from V4 to V5 format for getAllEndpointsWidgetData:
  * - Filter format change: filters.items[] → filter.expression
  * - Aggregation format: aggregateAttribute → aggregations[] array
- * - Domain filter: http_host = '${domainName}'
+ * - Domain filter: (net.peer.name OR server.address)
  * - Kind filter: kind_string = 'Client'
  * - Four queries: A (count), B (p99 latency), C (max timestamp), D (error count - disabled)
- * - GroupBy: http_url with type 'attribute'
+ * - GroupBy: Both http.url AND url.full with type 'attribute'
  */
 import { getAllEndpointsWidgetData } from 'container/ApiMonitoring/utils';
 import {
@@ -18,8 +18,6 @@ import {
 } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 
-import { SPAN_ATTRIBUTES } from '../Explorer/Domains/DomainDetails/constants';
-
 describe('AllEndpointsWidget - V5 Migration Validation', () => {
 	const mockDomainName = 'api.example.com';
 	const emptyFilters: IBuilderQuery['filters'] = {
@@ -94,28 +92,28 @@ describe('AllEndpointsWidget - V5 Migration Validation', () => {
 
 			const [queryA, queryB, queryC, queryD] = widget.query.builder.queryData;
 
-			const baseExpression = `http_host = '${mockDomainName}' AND kind_string = 'Client'`;
+			const baseExpression = `(net.peer.name = '${mockDomainName}' OR server.address = '${mockDomainName}') AND kind_string = 'Client'`;
 
 			// Queries A, B, C have identical base filter
 			expect(queryA.filter?.expression).toBe(
-				`${baseExpression} AND ${SPAN_ATTRIBUTES.HTTP_URL} EXISTS`,
+				`${baseExpression} AND (http.url EXISTS OR url.full EXISTS)`,
 			);
 			expect(queryB.filter?.expression).toBe(
-				`${baseExpression} AND ${SPAN_ATTRIBUTES.HTTP_URL} EXISTS`,
+				`${baseExpression} AND (http.url EXISTS OR url.full EXISTS)`,
 			);
 			expect(queryC.filter?.expression).toBe(
-				`${baseExpression} AND ${SPAN_ATTRIBUTES.HTTP_URL} EXISTS`,
+				`${baseExpression} AND (http.url EXISTS OR url.full EXISTS)`,
 			);
 
 			// Query D has additional has_error filter
 			expect(queryD.filter?.expression).toBe(
-				`${baseExpression} AND has_error = true AND ${SPAN_ATTRIBUTES.HTTP_URL} EXISTS`,
+				`${baseExpression} AND has_error = true AND (http.url EXISTS OR url.full EXISTS)`,
 			);
 		});
 	});
 
 	describe('2. GroupBy Structure', () => {
-		it(`default groupBy includes ${SPAN_ATTRIBUTES.HTTP_URL} with type attribute`, () => {
+		it('default groupBy includes both http.url and url.full with type attribute', () => {
 			const widget = getAllEndpointsWidgetData(
 				emptyGroupBy,
 				mockDomainName,
@@ -126,13 +124,23 @@ describe('AllEndpointsWidget - V5 Migration Validation', () => {
 
 			// All queries should have the same default groupBy
 			queryData.forEach((query) => {
-				expect(query.groupBy).toHaveLength(1);
+				expect(query.groupBy).toHaveLength(2);
 
+				// http.url
 				expect(query.groupBy).toContainEqual({
 					dataType: DataTypes.String,
 					isColumn: false,
 					isJSON: false,
-					key: SPAN_ATTRIBUTES.HTTP_URL,
+					key: 'http.url',
+					type: 'attribute',
+				});
+
+				// url.full
+				expect(query.groupBy).toContainEqual({
+					dataType: DataTypes.String,
+					isColumn: false,
+					isJSON: false,
+					key: 'url.full',
 					type: 'attribute',
 				});
 			});
@@ -162,18 +170,19 @@ describe('AllEndpointsWidget - V5 Migration Validation', () => {
 
 			// All queries should have defaults + custom groupBy
 			queryData.forEach((query) => {
-				expect(query.groupBy).toHaveLength(3); // 1 default + 2 custom
+				expect(query.groupBy).toHaveLength(4); // 2 defaults + 2 custom
 
-				// First two should be defaults (http_url)
-				expect(query.groupBy[0].key).toBe(SPAN_ATTRIBUTES.HTTP_URL);
+				// First two should be defaults (http.url, url.full)
+				expect(query.groupBy[0].key).toBe('http.url');
+				expect(query.groupBy[1].key).toBe('url.full');
 
 				// Last two should be custom (matching subset of properties)
-				expect(query.groupBy[1]).toMatchObject({
+				expect(query.groupBy[2]).toMatchObject({
 					dataType: DataTypes.String,
 					key: 'service.name',
 					type: 'resource',
 				});
-				expect(query.groupBy[2]).toMatchObject({
+				expect(query.groupBy[3]).toMatchObject({
 					dataType: DataTypes.String,
 					key: 'deployment.environment',
 					type: 'resource',

frontend/src/container/ApiMonitoring/__tests__/EndPointDetails.test.tsx

@@ -258,7 +258,7 @@ describe('EndPointDetails Component', () => {
 			expect.objectContaining({
 				items: expect.arrayContaining([
 					expect.objectContaining({
-						key: expect.objectContaining({ key: SPAN_ATTRIBUTES.HTTP_URL }),
+						key: expect.objectContaining({ key: SPAN_ATTRIBUTES.URL_PATH }),
 						value: '/api/test',
 					}),
 				]),
@@ -278,7 +278,7 @@ describe('EndPointDetails Component', () => {
 			expect.objectContaining({
 				items: expect.arrayContaining([
 					expect.objectContaining({
-						key: expect.objectContaining({ key: SPAN_ATTRIBUTES.HTTP_URL }),
+						key: expect.objectContaining({ key: SPAN_ATTRIBUTES.URL_PATH }),
 						value: '/api/test',
 					}),
 				]),
@@ -360,7 +360,7 @@ describe('EndPointDetails Component', () => {
 			expect.objectContaining({
 				items: expect.arrayContaining([
 					expect.objectContaining({
-						key: expect.objectContaining({ key: SPAN_ATTRIBUTES.HTTP_URL }),
+						key: expect.objectContaining({ key: SPAN_ATTRIBUTES.URL_PATH }),
 						value: '/api/test',
 					}),
 				]),
@@ -373,7 +373,7 @@ describe('EndPointDetails Component', () => {
 			expect.objectContaining({
 				items: expect.arrayContaining([
 					expect.objectContaining({
-						key: expect.objectContaining({ key: SPAN_ATTRIBUTES.HTTP_URL }),
+						key: expect.objectContaining({ key: SPAN_ATTRIBUTES.URL_PATH }),
 						value: '/api/test',
 					}),
 				]),

frontend/src/container/ApiMonitoring/__tests__/EndPointsDropDown.test.tsx

@@ -191,7 +191,7 @@ describe('EndPointsDropDown Component', () => {
 
 	it('formats data using the utility function', () => {
 		const mockRows = [
-			{ data: { [SPAN_ATTRIBUTES.HTTP_URL]: '/api/test', A: 10 } },
+			{ data: { [SPAN_ATTRIBUTES.URL_PATH]: '/api/test', A: 10 } },
 		];
 
 		const dataProps = {

frontend/src/container/ApiMonitoring/__tests__/EndpointDropdownV5Migration.test.tsx

@@ -6,18 +6,15 @@
  * These tests validate the migration from V4 to V5 format for the third payload
  * in getEndPointDetailsQueryPayload (endpoint dropdown data):
  * - Filter format change: filters.items[] → filter.expression
- * - Domain handling: http_host = '${domainName}'
+ * - Domain handling: (net.peer.name OR server.address)
  * - Kind filter: kind_string = 'Client'
- * - Existence check: http_url EXISTS
+ * - Existence check: (http.url EXISTS OR url.full EXISTS)
  * - Aggregation: count() expression
- * - GroupBy: http_url with type 'attribute'
+ * - GroupBy: Both http.url AND url.full with type 'attribute'
  */
 import { getEndPointDetailsQueryPayload } from 'container/ApiMonitoring/utils';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 
-import { SPAN_ATTRIBUTES } from '../Explorer/Domains/DomainDetails/constants';
-
 describe('EndpointDropdown - V5 Migration Validation', () => {
 	const mockDomainName = 'api.example.com';
 	const mockStartTime = 1000;
@@ -46,9 +43,9 @@ describe('EndpointDropdown - V5 Migration Validation', () => {
 			expect(typeof queryA.filter?.expression).toBe('string');
 			expect(queryA).not.toHaveProperty('filters');
 
-			// Base filter 1: Domain http_host = '${domainName}'
+			// Base filter 1: Domain (net.peer.name OR server.address)
 			expect(queryA.filter?.expression).toContain(
-				`http_host = '${mockDomainName}'`,
+				`(net.peer.name = '${mockDomainName}' OR server.address = '${mockDomainName}')`,
 			);
 
 			// Base filter 2: Kind
@@ -56,7 +53,7 @@ describe('EndpointDropdown - V5 Migration Validation', () => {
 
 			// Base filter 3: Existence check
 			expect(queryA.filter?.expression).toContain(
-				`${SPAN_ATTRIBUTES.HTTP_URL} EXISTS`,
+				'(http.url EXISTS OR url.full EXISTS)',
 			);
 
 			// V5 Aggregation format: aggregations array (not aggregateAttribute)
@@ -67,11 +64,16 @@ describe('EndpointDropdown - V5 Migration Validation', () => {
 			});
 			expect(queryA).not.toHaveProperty('aggregateAttribute');
 
-			// GroupBy: http_url
-			expect(queryA.groupBy).toHaveLength(1);
+			// GroupBy: Both http.url and url.full
+			expect(queryA.groupBy).toHaveLength(2);
 			expect(queryA.groupBy).toContainEqual({
-				key: SPAN_ATTRIBUTES.HTTP_URL,
-				dataType: DataTypes.String,
+				key: 'http.url',
+				dataType: 'string',
+				type: 'attribute',
+			});
+			expect(queryA.groupBy).toContainEqual({
+				key: 'url.full',
+				dataType: 'string',
 				type: 'attribute',
 			});
 		});
@@ -118,7 +120,53 @@ describe('EndpointDropdown - V5 Migration Validation', () => {
 
 			// Exact filter expression with custom filters merged
 			expect(expression).toBe(
-				`${SPAN_ATTRIBUTES.SERVER_NAME} = 'api.example.com' AND kind_string = 'Client' AND ${SPAN_ATTRIBUTES.HTTP_URL} EXISTS service.name = 'user-service' AND deployment.environment = 'production'`,
+				"(net.peer.name = 'api.example.com' OR server.address = 'api.example.com') AND kind_string = 'Client' AND (http.url EXISTS OR url.full EXISTS) service.name = 'user-service' AND deployment.environment = 'production'",
+			);
+		});
+	});
+
+	describe('3. HTTP URL Filter Special Handling', () => {
+		it('converts http.url filter to (http.url OR url.full) expression', () => {
+			const filtersWithHttpUrl: IBuilderQuery['filters'] = {
+				items: [
+					{
+						id: 'http-url-filter',
+						key: {
+							key: 'http.url',
+							dataType: 'string' as any,
+							type: 'tag',
+						},
+						op: '=',
+						value: '/api/users',
+					},
+					{
+						id: 'service-filter',
+						key: {
+							key: 'service.name',
+							dataType: 'string' as any,
+							type: 'resource',
+						},
+						op: '=',
+						value: 'user-service',
+					},
+				],
+				op: 'AND',
+			};
+
+			const payload = getEndPointDetailsQueryPayload(
+				mockDomainName,
+				mockStartTime,
+				mockEndTime,
+				filtersWithHttpUrl,
+			);
+
+			const dropdownQuery = payload[2];
+			const expression =
+				dropdownQuery.query.builder.queryData[0].filter?.expression;
+
+			// CRITICAL: Exact filter expression with http.url converted to OR logic
+			expect(expression).toBe(
+				"(net.peer.name = 'api.example.com' OR server.address = 'api.example.com') AND kind_string = 'Client' AND (http.url EXISTS OR url.full EXISTS) service.name = 'user-service' AND (http.url = '/api/users' OR url.full = '/api/users')",
 			);
 		});
 	});

frontend/src/container/ApiMonitoring/__tests__/MetricOverTimeV5Migration.test.tsx

@@ -33,7 +33,7 @@ describe('MetricOverTime - V5 Migration Validation', () => {
 			expect(queryData).not.toHaveProperty('filters.items');
 		});
 
-		it('uses new domain filter format: (http_host)', () => {
+		it('uses new domain filter format: (net.peer.name OR server.address)', () => {
 			const widget = getRateOverTimeWidgetData(
 				mockDomainName,
 				mockEndpointName,
@@ -44,7 +44,7 @@ describe('MetricOverTime - V5 Migration Validation', () => {
 
 			// Verify EXACT new filter format with OR operator
 			expect(queryData?.filter?.expression).toContain(
-				`http_host = '${mockDomainName}'`,
+				`(net.peer.name = '${mockDomainName}' OR server.address = '${mockDomainName}')`,
 			);
 
 			// Endpoint name is used in legend, not filter
@@ -90,7 +90,7 @@ describe('MetricOverTime - V5 Migration Validation', () => {
 
 			// Verify domain filter is present
 			expect(queryData?.filter?.expression).toContain(
-				`http_host = '${mockDomainName}'`,
+				`(net.peer.name = '${mockDomainName}' OR server.address = '${mockDomainName}')`,
 			);
 
 			// Verify custom filters are merged into the expression
@@ -120,7 +120,7 @@ describe('MetricOverTime - V5 Migration Validation', () => {
 			expect(queryData).not.toHaveProperty('filters.items');
 		});
 
-		it('uses new domain filter format: (http_host)', () => {
+		it('uses new domain filter format: (net.peer.name OR server.address)', () => {
 			const widget = getLatencyOverTimeWidgetData(
 				mockDomainName,
 				mockEndpointName,
@@ -132,7 +132,7 @@ describe('MetricOverTime - V5 Migration Validation', () => {
 			// Verify EXACT new filter format with OR operator
 			expect(queryData.filter).toBeDefined();
 			expect(queryData?.filter?.expression).toContain(
-				`http_host = '${mockDomainName}'`,
+				`(net.peer.name = '${mockDomainName}' OR server.address = '${mockDomainName}')`,
 			);
 
 			// Endpoint name is used in legend, not filter
@@ -166,7 +166,7 @@ describe('MetricOverTime - V5 Migration Validation', () => {
 
 			// Verify domain filter is present
 			expect(queryData?.filter?.expression).toContain(
-				`http_host = '${mockDomainName}' service.name = 'user-service'`,
+				`(net.peer.name = '${mockDomainName}' OR server.address = '${mockDomainName}') service.name = 'user-service'`,
 			);
 		});
 	});

frontend/src/container/ApiMonitoring/__tests__/StatusCodeBarCharts.test.tsx

@@ -142,6 +142,7 @@ describe('StatusCodeBarCharts', () => {
 		endTime: 1609545600000,
 	};
 	const mockDomainName = 'test-domain';
+	const mockEndPointName = '/api/test';
 	const onDragSelectMock = jest.fn();
 	const refetchFn = jest.fn();
 
@@ -231,6 +232,7 @@ describe('StatusCodeBarCharts', () => {
 				endPointStatusCodeBarChartsDataQuery={mockStatusCodeQuery as any}
 				endPointStatusCodeLatencyBarChartsDataQuery={mockLatencyQuery as any}
 				domainName={mockDomainName}
+				endPointName={mockEndPointName}
 				filters={mockFilters}
 				timeRange={mockTimeRange}
 				onDragSelect={onDragSelectMock}
@@ -266,6 +268,7 @@ describe('StatusCodeBarCharts', () => {
 				endPointStatusCodeBarChartsDataQuery={mockStatusCodeQuery as any}
 				endPointStatusCodeLatencyBarChartsDataQuery={mockLatencyQuery as any}
 				domainName={mockDomainName}
+				endPointName={mockEndPointName}
 				filters={mockFilters}
 				timeRange={mockTimeRange}
 				onDragSelect={onDragSelectMock}
@@ -308,6 +311,7 @@ describe('StatusCodeBarCharts', () => {
 				endPointStatusCodeBarChartsDataQuery={mockStatusCodeQuery as any}
 				endPointStatusCodeLatencyBarChartsDataQuery={mockLatencyQuery as any}
 				domainName={mockDomainName}
+				endPointName={mockEndPointName}
 				filters={mockFilters}
 				timeRange={mockTimeRange}
 				onDragSelect={onDragSelectMock}
@@ -352,6 +356,7 @@ describe('StatusCodeBarCharts', () => {
 				endPointStatusCodeBarChartsDataQuery={mockStatusCodeQuery as any}
 				endPointStatusCodeLatencyBarChartsDataQuery={mockLatencyQuery as any}
 				domainName={mockDomainName}
+				endPointName={mockEndPointName}
 				filters={mockFilters}
 				timeRange={mockTimeRange}
 				onDragSelect={onDragSelectMock}
@@ -399,6 +404,7 @@ describe('StatusCodeBarCharts', () => {
 				endPointStatusCodeBarChartsDataQuery={mockStatusCodeQuery as any}
 				endPointStatusCodeLatencyBarChartsDataQuery={mockLatencyQuery as any}
 				domainName={mockDomainName}
+				endPointName={mockEndPointName}
 				filters={mockFilters}
 				timeRange={mockTimeRange}
 				onDragSelect={onDragSelectMock}
@@ -413,6 +419,7 @@ describe('StatusCodeBarCharts', () => {
 		// but we've confirmed the function is mocked and ready to be tested
 		expect(getStatusCodeBarChartWidgetData).toHaveBeenCalledWith(
 			mockDomainName,
+			mockEndPointName,
 			expect.objectContaining({
 				items: [],
 				op: 'AND',
@@ -460,6 +467,7 @@ describe('StatusCodeBarCharts', () => {
 				endPointStatusCodeBarChartsDataQuery={mockStatusCodeQuery as any}
 				endPointStatusCodeLatencyBarChartsDataQuery={mockLatencyQuery as any}
 				domainName={mockDomainName}
+				endPointName={mockEndPointName}
 				filters={mockCustomFilters as IBuilderQuery['filters']}
 				timeRange={mockTimeRange}
 				onDragSelect={onDragSelectMock}
@@ -469,6 +477,7 @@ describe('StatusCodeBarCharts', () => {
 		// Assert widget creation was called with the correct parameters
 		expect(getStatusCodeBarChartWidgetData).toHaveBeenCalledWith(
 			mockDomainName,
+			mockEndPointName,
 			expect.objectContaining({
 				items: expect.arrayContaining([
 					expect.objectContaining({ id: 'custom-filter' }),

frontend/src/container/ApiMonitoring/__tests__/StatusCodeBarChartsV5Migration.test.tsx

@@ -10,7 +10,7 @@
  *
  * V5 Changes:
  * - Filter format change: filters.items[] → filter.expression
- * - Domain filter: (http_host)
+ * - Domain filter: (net.peer.name OR server.address)
  * - Kind filter: kind_string = 'Client'
  * - stepInterval: 60 → null
  * - Grouped by response_status_code
@@ -47,9 +47,9 @@ describe('StatusCodeBarCharts - V5 Migration Validation', () => {
 			expect(typeof queryA.filter?.expression).toBe('string');
 			expect(queryA).not.toHaveProperty('filters.items');
 
-			// Base filter 1: Domain (http_host)
+			// Base filter 1: Domain (net.peer.name OR server.address)
 			expect(queryA.filter?.expression).toContain(
-				`http_host = '${mockDomainName}'`,
+				`(net.peer.name = '${mockDomainName}' OR server.address = '${mockDomainName}')`,
 			);
 
 			// Base filter 2: Kind
@@ -96,9 +96,9 @@ describe('StatusCodeBarCharts - V5 Migration Validation', () => {
 			expect(typeof queryA.filter?.expression).toBe('string');
 			expect(queryA).not.toHaveProperty('filters.items');
 
-			// Base filter 1: Domain (http_host)
+			// Base filter 1: Domain (net.peer.name OR server.address)
 			expect(queryA.filter?.expression).toContain(
-				`http_host = '${mockDomainName}'`,
+				`(net.peer.name = '${mockDomainName}' OR server.address = '${mockDomainName}')`,
 			);
 
 			// Base filter 2: Kind
@@ -177,7 +177,7 @@ describe('StatusCodeBarCharts - V5 Migration Validation', () => {
 			expect(callsExpression).toBe(latencyExpression);
 
 			// Verify base filters
-			expect(callsExpression).toContain('http_host');
+			expect(callsExpression).toContain('net.peer.name');
 			expect(callsExpression).toContain("kind_string = 'Client'");
 
 			// Verify custom filters are merged
@@ -187,4 +187,51 @@ describe('StatusCodeBarCharts - V5 Migration Validation', () => {
 			expect(callsExpression).toContain('production');
 		});
 	});
+
+	describe('4. HTTP URL Filter Handling', () => {
+		it('converts http.url filter to (http.url OR url.full) expression in both charts', () => {
+			const filtersWithHttpUrl: IBuilderQuery['filters'] = {
+				items: [
+					{
+						id: 'http-url-filter',
+						key: {
+							key: 'http.url',
+							dataType: 'string' as any,
+							type: 'tag',
+						},
+						op: '=',
+						value: '/api/metrics',
+					},
+				],
+				op: 'AND',
+			};
+
+			const payload = getEndPointDetailsQueryPayload(
+				mockDomainName,
+				mockStartTime,
+				mockEndTime,
+				filtersWithHttpUrl,
+			);
+
+			const callsChartQuery = payload[4];
+			const latencyChartQuery = payload[5];
+
+			const callsExpression =
+				callsChartQuery.query.builder.queryData[0].filter?.expression;
+			const latencyExpression =
+				latencyChartQuery.query.builder.queryData[0].filter?.expression;
+
+			// CRITICAL: http.url converted to OR logic
+			expect(callsExpression).toContain(
+				"(http.url = '/api/metrics' OR url.full = '/api/metrics')",
+			);
+			expect(latencyExpression).toContain(
+				"(http.url = '/api/metrics' OR url.full = '/api/metrics')",
+			);
+
+			// Base filters still present
+			expect(callsExpression).toContain('net.peer.name');
+			expect(callsExpression).toContain("kind_string = 'Client'");
+		});
+	});
 });

frontend/src/container/ApiMonitoring/__tests__/StatusCodeTableV5Migration.test.tsx

@@ -6,8 +6,8 @@
  * These tests validate the migration from V4 to V5 format for the second payload
  * in getEndPointDetailsQueryPayload (status code table data):
  * - Filter format change: filters.items[] → filter.expression
- * - URL handling: Special logic for http_url
- * - Domain filter: http_host = '${domainName}'
+ * - URL handling: Special logic for (http.url OR url.full)
+ * - Domain filter: (net.peer.name OR server.address)
  * - Kind filter: kind_string = 'Client'
  * - Kind filter: response_status_code EXISTS
  * - Three queries: A (count), B (p99 latency), C (rate)
@@ -45,9 +45,9 @@ describe('StatusCodeTable - V5 Migration Validation', () => {
 			expect(typeof queryA.filter?.expression).toBe('string');
 			expect(queryA).not.toHaveProperty('filters.items');
 
-			// Base filter 1: Domain (http_host)
+			// Base filter 1: Domain (net.peer.name OR server.address)
 			expect(queryA.filter?.expression).toContain(
-				`http_host = '${mockDomainName}'`,
+				`(net.peer.name = '${mockDomainName}' OR server.address = '${mockDomainName}')`,
 			);
 
 			// Base filter 2: Kind
@@ -149,7 +149,7 @@ describe('StatusCodeTable - V5 Migration Validation', () => {
 				statusCodeQuery.query.builder.queryData[0].filter?.expression;
 
 			// Base filters present
-			expect(expression).toContain('http_host');
+			expect(expression).toContain('net.peer.name');
 			expect(expression).toContain("kind_string = 'Client'");
 			expect(expression).toContain('response_status_code EXISTS');
 
@@ -165,4 +165,62 @@ describe('StatusCodeTable - V5 Migration Validation', () => {
 			expect(queries[1].filter?.expression).toBe(queries[2].filter?.expression);
 		});
 	});
+
+	describe('4. HTTP URL Filter Handling', () => {
+		it('converts http.url filter to (http.url OR url.full) expression', () => {
+			const filtersWithHttpUrl: IBuilderQuery['filters'] = {
+				items: [
+					{
+						id: 'http-url-filter',
+						key: {
+							key: 'http.url',
+							dataType: 'string' as any,
+							type: 'tag',
+						},
+						op: '=',
+						value: '/api/users',
+					},
+					{
+						id: 'service-filter',
+						key: {
+							key: 'service.name',
+							dataType: 'string' as any,
+							type: 'resource',
+						},
+						op: '=',
+						value: 'user-service',
+					},
+				],
+				op: 'AND',
+			};
+
+			const payload = getEndPointDetailsQueryPayload(
+				mockDomainName,
+				mockStartTime,
+				mockEndTime,
+				filtersWithHttpUrl,
+			);
+
+			const statusCodeQuery = payload[1];
+			const expression =
+				statusCodeQuery.query.builder.queryData[0].filter?.expression;
+
+			// CRITICAL: http.url converted to OR logic
+			expect(expression).toContain(
+				"(http.url = '/api/users' OR url.full = '/api/users')",
+			);
+
+			// Other filters still present
+			expect(expression).toContain('service.name');
+			expect(expression).toContain('user-service');
+
+			// Base filters present
+			expect(expression).toContain('net.peer.name');
+			expect(expression).toContain("kind_string = 'Client'");
+			expect(expression).toContain('response_status_code EXISTS');
+
+			// All ANDed together (at least 2 ANDs: domain+kind, custom filter, url condition)
+			expect(expression?.match(/AND/g)?.length).toBeGreaterThanOrEqual(2);
+		});
+	});
 });

frontend/src/container/ApiMonitoring/__tests__/TopErrors.test.tsx

@@ -84,7 +84,7 @@ describe('TopErrors', () => {
 									{
 										columns: [
 											{
-												name: SPAN_ATTRIBUTES.HTTP_URL,
+												name: 'http.url',
 												fieldDataType: 'string',
 												fieldContext: 'attribute',
 											},
@@ -124,7 +124,7 @@ describe('TopErrors', () => {
 										table: {
 											rows: [
 												{
-													http_url: '/api/test',
+													'http.url': '/api/test',
 													A: 100,
 												},
 											],
@@ -206,7 +206,7 @@ describe('TopErrors', () => {
 		expect(navigateMock).toHaveBeenCalledWith({
 			filters: expect.arrayContaining([
 				expect.objectContaining({
-					key: expect.objectContaining({ key: SPAN_ATTRIBUTES.HTTP_URL }),
+					key: expect.objectContaining({ key: 'http.url' }),
 					op: '=',
 					value: '/api/test',
 				}),
@@ -335,7 +335,7 @@ describe('TopErrors', () => {
 
 		// Verify all required filters are present
 		expect(filterExpression).toContain(
-			`kind_string = 'Client' AND ${SPAN_ATTRIBUTES.HTTP_URL} EXISTS AND ${SPAN_ATTRIBUTES.SERVER_NAME} = 'test-domain' AND has_error = true`,
+			`kind_string = 'Client' AND (http.url EXISTS OR url.full EXISTS) AND (net.peer.name = 'test-domain' OR server.address = 'test-domain') AND has_error = true`,
 		);
 	});
 });

frontend/src/container/ApiMonitoring/utils.tsx

@@ -15,6 +15,7 @@ import { getWidgetQueryBuilder } from 'container/MetricsApplication/MetricsAppli
 import { convertNanoToMilliseconds } from 'container/MetricsExplorer/Summary/utils';
 import dayjs from 'dayjs';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
+import { RowData } from 'lib/query/createTableColumnsFromQuery';
 import { cloneDeep } from 'lodash-es';
 import { ArrowUpDown, ChevronDown, ChevronRight, Info } from 'lucide-react';
 import { getWidgetQuery } from 'pages/MessagingQueues/MQDetails/MetricPage/MetricPageUtil';
@@ -56,12 +57,12 @@ export const getDisplayValue = (value: unknown): string =>
 	isEmptyFilterValue(value) ? '-' : String(value);
 
 export const getDomainNameFilterExpression = (domainName: string): string =>
-	`http_host = '${domainName}'`;
+	`(net.peer.name = '${domainName}' OR server.address = '${domainName}')`;
 
 export const clientKindExpression = `kind_string = 'Client'`;
 
 /**
- * Converts filters to expression
+ * Converts filters to expression, handling http.url specially by creating (http.url OR url.full) condition
  * @param filters Filters to convert
  * @param baseExpression Base expression to combine with filters
  * @returns Filter expression string
@@ -74,6 +75,34 @@ export const convertFiltersWithUrlHandling = (
 		return baseExpression;
 	}
 
+	// Check if filters contain http.url (SPAN_ATTRIBUTES.URL_PATH)
+	const httpUrlFilter = filters.items?.find(
+		(item) => item.key?.key === SPAN_ATTRIBUTES.URL_PATH,
+	);
+
+	// If http.url filter exists, create modified filters with (http.url OR url.full)
+	if (httpUrlFilter && httpUrlFilter.value) {
+		// Remove ALL http.url filters from items (guards against duplicates)
+		const otherFilters = filters.items?.filter(
+			(item) => item.key?.key !== SPAN_ATTRIBUTES.URL_PATH,
+		);
+
+		// Convert to expression first with other filters
+		const {
+			filter: intermediateFilter,
+		} = convertFiltersToExpressionWithExistingQuery(
+			{ ...filters, items: otherFilters || [] },
+			baseExpression,
+		);
+
+		// Add the OR condition for http.url and url.full
+		const urlValue = httpUrlFilter.value;
+		const urlCondition = `(http.url = '${urlValue}' OR url.full = '${urlValue}')`;
+		return intermediateFilter.expression.trim()
+			? `${intermediateFilter.expression} AND ${urlCondition}`
+			: urlCondition;
+	}
+
 	const { filter } = convertFiltersToExpressionWithExistingQuery(
 		filters,
 		baseExpression,
@@ -342,7 +371,7 @@ export const formatDataForTable = (
 	});
 };
 
-const urlExpression = `${SPAN_ATTRIBUTES.HTTP_URL} EXISTS`;
+const urlExpression = `(url.full EXISTS OR http.url EXISTS)`;
 
 export const getDomainMetricsQueryPayload = (
 	domainName: string,
@@ -559,7 +588,14 @@ const defaultGroupBy = [
 		dataType: DataTypes.String,
 		isColumn: false,
 		isJSON: false,
-		key: SPAN_ATTRIBUTES.HTTP_URL,
+		key: SPAN_ATTRIBUTES.URL_PATH,
+		type: 'attribute',
+	},
+	{
+		dataType: DataTypes.String,
+		isColumn: false,
+		isJSON: false,
+		key: 'url.full',
 		type: 'attribute',
 	},
 	// {
@@ -831,8 +867,8 @@ function buildFilterExpression(
 ): string {
 	const baseFilterParts = [
 		`kind_string = 'Client'`,
-		`${SPAN_ATTRIBUTES.HTTP_URL} EXISTS`,
-		`${SPAN_ATTRIBUTES.SERVER_NAME} = '${domainName}'`,
+		`(http.url EXISTS OR url.full EXISTS)`,
+		`(net.peer.name = '${domainName}' OR server.address = '${domainName}')`,
 		`has_error = true`,
 	];
 	if (showStatusCodeErrors) {
@@ -874,7 +910,12 @@ export const getTopErrorsQueryPayload = (
 						filter: { expression: filterExpression },
 						groupBy: [
 							{
-								name: SPAN_ATTRIBUTES.HTTP_URL,
+								name: 'http.url',
+								fieldDataType: 'string',
+								fieldContext: 'attribute',
+							},
+							{
+								name: 'url.full',
 								fieldDataType: 'string',
 								fieldContext: 'attribute',
 							},
@@ -1093,11 +1134,11 @@ export const formatEndPointsDataForTable = (
 	if (!isGroupedByAttribute) {
 		formattedData = data?.map((endpoint) => {
 			const { port } = extractPortAndEndpoint(
-				(endpoint.data[SPAN_ATTRIBUTES.HTTP_URL] as string) || '',
+				(endpoint.data[SPAN_ATTRIBUTES.URL_PATH] as string) || '',
 			);
 			return {
 				key: v4(),
-				endpointName: (endpoint.data[SPAN_ATTRIBUTES.HTTP_URL] as string) || '-',
+				endpointName: (endpoint.data[SPAN_ATTRIBUTES.URL_PATH] as string) || '-',
 				port,
 				callCount:
 					endpoint.data.A === 'n/a' || endpoint.data.A === undefined
@@ -1221,7 +1262,9 @@ export const formatTopErrorsDataForTable = (
 
 		return {
 			key: v4(),
-			endpointName: getDisplayValue(rowObj[SPAN_ATTRIBUTES.HTTP_URL]),
+			endpointName: getDisplayValue(
+				rowObj[SPAN_ATTRIBUTES.URL_PATH] || rowObj['url.full'],
+			),
 			statusCode: getDisplayValue(rowObj[SPAN_ATTRIBUTES.RESPONSE_STATUS_CODE]),
 			statusMessage: getDisplayValue(rowObj.status_message),
 			count: getDisplayValue(rowObj.__result_0),
@@ -1238,10 +1281,10 @@ export const getTopErrorsCoRelationQueryFilters = (
 		{
 			id: 'ea16470b',
 			key: {
-				key: SPAN_ATTRIBUTES.HTTP_URL,
+				key: 'http.url',
 				dataType: DataTypes.String,
 				type: 'tag',
-				id: `${SPAN_ATTRIBUTES.HTTP_URL}--string--tag--false`,
+				id: 'http.url--string--tag--false',
 			},
 			op: '=',
 			value: endPointName,
@@ -1738,7 +1781,7 @@ export const getEndPointDetailsQueryPayload = (
 								filters || { items: [], op: 'AND' },
 								`${getDomainNameFilterExpression(
 									domainName,
-								)} AND ${clientKindExpression} AND ${SPAN_ATTRIBUTES.HTTP_URL} EXISTS`,
+								)} AND ${clientKindExpression} AND (http.url EXISTS OR url.full EXISTS)`,
 							),
 						},
 						expression: 'A',
@@ -1750,7 +1793,12 @@ export const getEndPointDetailsQueryPayload = (
 						orderBy: [],
 						groupBy: [
 							{
-								key: SPAN_ATTRIBUTES.HTTP_URL,
+								key: SPAN_ATTRIBUTES.URL_PATH,
+								dataType: DataTypes.String,
+								type: 'attribute',
+							},
+							{
+								key: 'url.full',
 								dataType: DataTypes.String,
 								type: 'attribute',
 							},
@@ -2177,7 +2225,7 @@ export const getEndPointZeroStateQueryPayload = (
 						orderBy: [],
 						groupBy: [
 							{
-								key: SPAN_ATTRIBUTES.HTTP_URL,
+								key: SPAN_ATTRIBUTES.URL_PATH,
 								dataType: DataTypes.String,
 								type: 'tag',
 							},
@@ -2371,7 +2419,8 @@ export const statusCodeWidgetInfo = [
 
 interface EndPointDropDownResponseRow {
 	data: {
-		[SPAN_ATTRIBUTES.HTTP_URL]: string;
+		[SPAN_ATTRIBUTES.URL_PATH]: string;
+		'url.full': string;
 		A: number;
 	};
 }
@@ -2390,8 +2439,8 @@ export const getFormattedEndPointDropDownData = (
 	}
 	return data.map((row) => ({
 		key: v4(),
-		label: row.data[SPAN_ATTRIBUTES.HTTP_URL] || '-',
-		value: row.data[SPAN_ATTRIBUTES.HTTP_URL] || '-',
+		label: row.data[SPAN_ATTRIBUTES.URL_PATH] || row.data['url.full'] || '-',
+		value: row.data[SPAN_ATTRIBUTES.URL_PATH] || row.data['url.full'] || '-',
 	}));
 };
 
@@ -2720,6 +2769,7 @@ export const groupStatusCodes = (
 
 export const getStatusCodeBarChartWidgetData = (
 	domainName: string,
+	endPointName: string,
 	filters: IBuilderQuery['filters'],
 ): Widgets => ({
 	query: {
@@ -2748,6 +2798,20 @@ export const getStatusCodeBarChartWidgetData = (
 								op: '=',
 								value: domainName,
 							},
+							...(endPointName
+								? [
+										{
+											id: '8b1be6f0',
+											key: {
+												dataType: DataTypes.String,
+												key: SPAN_ATTRIBUTES.URL_PATH,
+												type: 'tag',
+											},
+											op: '=',
+											value: endPointName,
+										},
+								  ]
+								: []),
 							...(filters?.items || []),
 						],
 						op: 'AND',
@@ -2869,7 +2933,7 @@ export const getAllEndpointsWidgetData = (
 							filters,
 							`${getDomainNameFilterExpression(
 								domainName,
-							)} AND ${clientKindExpression} AND http_url EXISTS`,
+							)} AND ${clientKindExpression} AND (http.url EXISTS OR url.full EXISTS)`,
 						),
 					},
 					functions: [],
@@ -2901,7 +2965,7 @@ export const getAllEndpointsWidgetData = (
 							filters,
 							`${getDomainNameFilterExpression(
 								domainName,
-							)} AND ${clientKindExpression} AND http_url EXISTS`,
+							)} AND ${clientKindExpression} AND (http.url EXISTS OR url.full EXISTS)`,
 						),
 					},
 					functions: [],
@@ -2933,7 +2997,7 @@ export const getAllEndpointsWidgetData = (
 							filters,
 							`${getDomainNameFilterExpression(
 								domainName,
-							)} AND ${clientKindExpression} AND http_url EXISTS`,
+							)} AND ${clientKindExpression} AND (http.url EXISTS OR url.full EXISTS)`,
 						),
 					},
 					functions: [],
@@ -2965,7 +3029,7 @@ export const getAllEndpointsWidgetData = (
 							filters,
 							`${getDomainNameFilterExpression(
 								domainName,
-							)} AND ${clientKindExpression} AND has_error = true AND http_url EXISTS`,
+							)} AND ${clientKindExpression} AND has_error = true AND (http.url EXISTS OR url.full EXISTS)`,
 						),
 					},
 					functions: [],
@@ -2996,12 +3060,24 @@ export const getAllEndpointsWidgetData = (
 	);
 
 	widget.renderColumnCell = {
-		[SPAN_ATTRIBUTES.HTTP_URL]: (url: string | number): ReactNode => {
-			if (isEmptyFilterValue(url) || !url || url === 'n/a') {
+		[SPAN_ATTRIBUTES.URL_PATH]: (
+			url: string | number,
+			record?: RowData,
+		): ReactNode => {
+			// First try to use the url from the column value
+			let urlValue = url;
+
+			// If url is empty/null and we have the record, fallback to url.full
+			if (isEmptyFilterValue(url) && record) {
+				const { 'url.full': urlFull } = record;
+				urlValue = urlFull;
+			}
+
+			if (!urlValue || urlValue === 'n/a') {
 				return <span>-</span>;
 			}
 
-			const { endpoint } = extractPortAndEndpoint(String(url));
+			const { endpoint } = extractPortAndEndpoint(String(urlValue));
 			return <span>{getDisplayValue(endpoint)}</span>;
 		},
 		A: (numOfCalls: any): ReactNode => (
@@ -3056,8 +3132,8 @@ export const getAllEndpointsWidgetData = (
 	};
 
 	widget.customColTitles = {
-		[SPAN_ATTRIBUTES.HTTP_URL]: 'Endpoint',
-		[SPAN_ATTRIBUTES.SERVER_PORT]: 'Port',
+		[SPAN_ATTRIBUTES.URL_PATH]: 'Endpoint',
+		'net.peer.port': 'Port',
 	};
 
 	widget.title = (
@@ -3082,10 +3158,12 @@ export const getAllEndpointsWidgetData = (
 		</div>
 	);
 
+	widget.hiddenColumns = ['url.full'];
+
 	return widget;
 };
 
-const keysToRemove = [SPAN_ATTRIBUTES.HTTP_URL, 'A', 'B', 'C', 'F1'];
+const keysToRemove = ['http.url', 'url.full', 'A', 'B', 'C', 'F1'];
 
 export const getGroupByFiltersFromGroupByValues = (
 	rowData: any,
@@ -3143,7 +3221,7 @@ export const getRateOverTimeWidgetData = (
 					filter: {
 						expression: convertFiltersWithUrlHandling(
 							filters || { items: [], op: 'AND' },
-							`http_host = '${domainName}'`,
+							`(net.peer.name = '${domainName}' OR server.address = '${domainName}')`,
 						),
 					},
 					functions: [],
@@ -3194,7 +3272,7 @@ export const getLatencyOverTimeWidgetData = (
 					filter: {
 						expression: convertFiltersWithUrlHandling(
 							filters || { items: [], op: 'AND' },
-							`http_host = '${domainName}'`,
+							`(net.peer.name = '${domainName}' OR server.address = '${domainName}')`,
 						),
 					},
 					functions: [],

frontend/src/container/CustomDomainSettings/CustomDomainSettings.tsx

@@ -1,6 +1,7 @@
 /* eslint-disable jsx-a11y/no-static-element-interactions */
 /* eslint-disable jsx-a11y/click-events-have-key-events */
-import { useEffect, useMemo, useState } from 'react';
+import { useEffect, useState } from 'react';
+import { useMutation } from 'react-query';
 import { useCopyToClipboard } from 'react-use';
 import { Color } from '@signozhq/design-tokens';
 import {
@@ -14,16 +15,14 @@ import {
 	Tag,
 	Typography,
 } from 'antd';
-import {
-	RenderErrorResponseDTO,
-	ZeustypesHostDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { useGetHosts, usePutHost } from 'api/generated/services/zeus';
+import updateSubDomainAPI from 'api/customDomain/updateSubDomain';
 import { AxiosError } from 'axios';
 import LaunchChatSupport from 'components/LaunchChatSupport/LaunchChatSupport';
+import { useGetDeploymentsData } from 'hooks/CustomDomain/useGetDeploymentsData';
 import { useNotifications } from 'hooks/useNotifications';
 import { InfoIcon, Link2, Pencil } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
+import { HostsProps } from 'types/api/customDomain/types';
 
 import './CustomDomainSettings.styles.scss';
 
@@ -36,7 +35,7 @@ export default function CustomDomainSettings(): JSX.Element {
 	const { notifications } = useNotifications();
 	const [isEditModalOpen, setIsEditModalOpen] = useState(false);
 	const [isPollingEnabled, setIsPollingEnabled] = useState(false);
-	const [hosts, setHosts] = useState<ZeustypesHostDTO[] | null>(null);
+	const [hosts, setHosts] = useState<HostsProps[] | null>(null);
 
 	const [updateDomainError, setUpdateDomainError] = useState<AxiosError | null>(
 		null,
@@ -58,37 +57,36 @@ export default function CustomDomainSettings(): JSX.Element {
 	};
 
 	const {
-		data: hostsData,
-		isLoading: isLoadingHosts,
-		isFetching: isFetchingHosts,
-		refetch: refetchHosts,
-	} = useGetHosts();
+		data: deploymentsData,
+		isLoading: isLoadingDeploymentsData,
+		isFetching: isFetchingDeploymentsData,
+		refetch: refetchDeploymentsData,
+	} = useGetDeploymentsData(true);
 
 	const {
 		mutate: updateSubDomain,
 		isLoading: isLoadingUpdateCustomDomain,
-	} = usePutHost<AxiosError<RenderErrorResponseDTO>>();
-
-	const stripProtocol = (url: string): string => {
-		return url?.split('://')[1] ?? url;
-	};
-
-	const dnsSuffix = useMemo(() => {
-		const defaultHost = hosts?.find((h) => h.is_default);
-		return defaultHost?.url && defaultHost?.name
-			? defaultHost.url.split(`${defaultHost.name}.`)[1] || ''
-			: '';
-	}, [hosts]);
+	} = useMutation(updateSubDomainAPI, {
+		onSuccess: () => {
+			setIsPollingEnabled(true);
+			refetchDeploymentsData();
+			setIsEditModalOpen(false);
+		},
+		onError: (error: AxiosError) => {
+			setUpdateDomainError(error);
+			setIsPollingEnabled(false);
+		},
+	});
 
 	useEffect(() => {
-		if (isFetchingHosts) {
+		if (isFetchingDeploymentsData) {
 			return;
 		}
 
-		if (hostsData?.data?.status === 'success') {
-			setHosts(hostsData?.data?.data?.hosts ?? null);
+		if (deploymentsData?.data?.status === 'success') {
+			setHosts(deploymentsData.data.data.hosts);
 
-			const activeCustomDomain = hostsData?.data?.data?.hosts?.find(
+			const activeCustomDomain = deploymentsData.data.data.hosts.find(
 				(host) => !host.is_default,
 			);
 
@@ -99,36 +97,32 @@ export default function CustomDomainSettings(): JSX.Element {
 			}
 		}
 
-		if (hostsData?.data?.data?.state !== 'HEALTHY' && isPollingEnabled) {
+		if (deploymentsData?.data?.data?.state !== 'HEALTHY' && isPollingEnabled) {
 			setTimeout(() => {
-				refetchHosts();
+				refetchDeploymentsData();
 			}, 3000);
 		}
 
-		if (hostsData?.data?.data?.state === 'HEALTHY') {
+		if (deploymentsData?.data?.data.state === 'HEALTHY') {
 			setIsPollingEnabled(false);
 		}
-	}, [hostsData, refetchHosts, isPollingEnabled, isFetchingHosts]);
+	}, [
+		deploymentsData,
+		refetchDeploymentsData,
+		isPollingEnabled,
+		isFetchingDeploymentsData,
+	]);
 
 	const onUpdateCustomDomainSettings = (): void => {
 		editForm
 			.validateFields()
 			.then((values) => {
 				if (values.subdomain) {
-					updateSubDomain(
-						{ data: { name: values.subdomain } },
-						{
-							onSuccess: () => {
-								setIsPollingEnabled(true);
-								refetchHosts();
-								setIsEditModalOpen(false);
-							},
-							onError: (error: AxiosError<RenderErrorResponseDTO>) => {
-								setUpdateDomainError(error as AxiosError);
-								setIsPollingEnabled(false);
-							},
+					updateSubDomain({
+						data: {
+							name: values.subdomain,
 						},
-					);
+					});
 
 					setCustomDomainDetails({
 						subdomain: values.subdomain,
@@ -140,8 +134,10 @@ export default function CustomDomainSettings(): JSX.Element {
 			});
 	};
 
-	const onCopyUrlHandler = (url: string): void => {
-		setCopyUrl(stripProtocol(url));
+	const onCopyUrlHandler = (host: string): void => {
+		const url = `${host}.${deploymentsData?.data.data.cluster.region.dns}`;
+
+		setCopyUrl(url);
 		notifications.success({
 			message: 'Copied to clipboard',
 		});
@@ -161,7 +157,7 @@ export default function CustomDomainSettings(): JSX.Element {
 			</div>
 
 			<div className="custom-domain-settings-content">
-				{!isLoadingHosts && (
+				{!isLoadingDeploymentsData && (
 					<Card className="custom-domain-settings-card">
 						<div className="custom-domain-settings-content-header">
 							Team {org?.[0]?.displayName} Information
@@ -173,9 +169,10 @@ export default function CustomDomainSettings(): JSX.Element {
 									<div
 										className="custom-domain-url"
 										key={host.name}
-										onClick={(): void => onCopyUrlHandler(host.url || '')}
+										onClick={(): void => onCopyUrlHandler(host.name)}
 									>
-										<Link2 size={12} /> {stripProtocol(host.url || '')}
+										<Link2 size={12} /> {host.name}.
+										{deploymentsData?.data.data.cluster.region.dns}
 										{host.is_default && <Tag color={Color.BG_ROBIN_500}>Default</Tag>}
 									</div>
 								))}
@@ -184,7 +181,11 @@ export default function CustomDomainSettings(): JSX.Element {
 							<div className="custom-domain-url-edit-btn">
 								<Button
 									className="periscope-btn"
-									disabled={isLoadingHosts || isFetchingHosts || isPollingEnabled}
+									disabled={
+										isLoadingDeploymentsData ||
+										isFetchingDeploymentsData ||
+										isPollingEnabled
+									}
 									type="default"
 									icon={<Pencil size={10} />}
 									onClick={(): void => setIsEditModalOpen(true)}
@@ -197,7 +198,7 @@ export default function CustomDomainSettings(): JSX.Element {
 						{isPollingEnabled && (
 							<Alert
 								className="custom-domain-update-status"
-								message={`Updating your URL to ⎯ ${customDomainDetails?.subdomain}.${dnsSuffix}. This may take a few mins.`}
+								message={`Updating your URL to ⎯ ${customDomainDetails?.subdomain}.${deploymentsData?.data.data.cluster.region.dns}. This may take a few mins.`}
 								type="info"
 								icon={<InfoIcon size={12} />}
 							/>
@@ -205,7 +206,7 @@ export default function CustomDomainSettings(): JSX.Element {
 					</Card>
 				)}
 
-				{isLoadingHosts && (
+				{isLoadingDeploymentsData && (
 					<Card className="custom-domain-settings-card">
 						<Skeleton
 							className="custom-domain-settings-skeleton"
@@ -254,7 +255,7 @@ export default function CustomDomainSettings(): JSX.Element {
 									addonBefore={updateDomainError && <InfoIcon size={12} color="red" />}
 									placeholder="Enter Domain"
 									onChange={(): void => setUpdateDomainError(null)}
-									addonAfter={dnsSuffix}
+									addonAfter={deploymentsData?.data.data.cluster.region.dns}
 									autoFocus
 								/>
 							</Form.Item>
@@ -266,8 +267,7 @@ export default function CustomDomainSettings(): JSX.Element {
 							{updateDomainError.status === 409 ? (
 								<Alert
 									message={
-										(updateDomainError?.response?.data as RenderErrorResponseDTO)?.error
-											?.message ||
+										(updateDomainError?.response?.data as { error?: string })?.error ||
 										'You’ve already updated the custom domain once today. To make further changes, please contact our support team for assistance.'
 									}
 									type="warning"
@@ -275,10 +275,7 @@ export default function CustomDomainSettings(): JSX.Element {
 								/>
 							) : (
 								<Typography.Text type="danger">
-									{
-										(updateDomainError?.response?.data as RenderErrorResponseDTO)?.error
-											?.message
-									}
+									{(updateDomainError.response?.data as { error: string })?.error}
 								</Typography.Text>
 							)}
 						</div>

frontend/src/container/CustomDomainSettings/__tests__/CustomDomainSettings.test.tsx

@@ -1,128 +0,0 @@
-import { GetHosts200 } from 'api/generated/services/sigNoz.schemas';
-import { rest, server } from 'mocks-server/server';
-import { render, screen, userEvent, waitFor } from 'tests/test-utils';
-
-import CustomDomainSettings from '../CustomDomainSettings';
-
-const ZEUS_HOSTS_ENDPOINT = '*/api/v2/zeus/hosts';
-
-const mockHostsResponse: GetHosts200 = {
-	status: 'success',
-	data: {
-		name: 'accepted-starfish',
-		state: 'HEALTHY',
-		tier: 'PREMIUM',
-		hosts: [
-			{
-				name: 'accepted-starfish',
-				is_default: true,
-				url: 'https://accepted-starfish.test.cloud',
-			},
-			{
-				name: 'custom-host',
-				is_default: false,
-				url: 'https://custom-host.test.cloud',
-			},
-		],
-	},
-};
-
-describe('CustomDomainSettings', () => {
-	afterEach(() => server.resetHandlers());
-
-	it('renders host URLs with protocol stripped and marks the default host', async () => {
-		server.use(
-			rest.get(ZEUS_HOSTS_ENDPOINT, (_, res, ctx) =>
-				res(ctx.status(200), ctx.json(mockHostsResponse)),
-			),
-		);
-
-		render(<CustomDomainSettings />);
-
-		await screen.findByText(/accepted-starfish\.test\.cloud/i);
-		await screen.findByText(/custom-host\.test\.cloud/i);
-		expect(screen.getByText('Default')).toBeInTheDocument();
-	});
-
-	it('opens edit modal with DNS suffix derived from the default host', async () => {
-		server.use(
-			rest.get(ZEUS_HOSTS_ENDPOINT, (_, res, ctx) =>
-				res(ctx.status(200), ctx.json(mockHostsResponse)),
-			),
-		);
-
-		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		render(<CustomDomainSettings />);
-
-		await screen.findByText(/accepted-starfish\.test\.cloud/i);
-
-		await user.click(
-			screen.getByRole('button', { name: /customize team['’]s url/i }),
-		);
-
-		expect(
-			screen.getByRole('dialog', { name: /customize your team['’]s url/i }),
-		).toBeInTheDocument();
-		// DNS suffix is the part of the default host URL after the name prefix
-		expect(screen.getByText('test.cloud')).toBeInTheDocument();
-	});
-
-	it('submits PUT to /zeus/hosts with the entered subdomain as the payload', async () => {
-		let capturedBody: Record<string, unknown> = {};
-
-		server.use(
-			rest.get(ZEUS_HOSTS_ENDPOINT, (_, res, ctx) =>
-				res(ctx.status(200), ctx.json(mockHostsResponse)),
-			),
-			rest.put(ZEUS_HOSTS_ENDPOINT, async (req, res, ctx) => {
-				capturedBody = await req.json<Record<string, unknown>>();
-				return res(ctx.status(200), ctx.json({}));
-			}),
-		);
-
-		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		render(<CustomDomainSettings />);
-
-		await screen.findByText(/accepted-starfish\.test\.cloud/i);
-		await user.click(
-			screen.getByRole('button', { name: /customize team['’]s url/i }),
-		);
-
-		const input = screen.getByPlaceholderText(/enter domain/i);
-		await user.clear(input);
-		await user.type(input, 'myteam');
-		await user.click(screen.getByRole('button', { name: /apply changes/i }));
-
-		await waitFor(() => {
-			expect(capturedBody).toEqual({ name: 'myteam' });
-		});
-	});
-
-	it('shows contact support option when domain update returns 409', async () => {
-		server.use(
-			rest.get(ZEUS_HOSTS_ENDPOINT, (_, res, ctx) =>
-				res(ctx.status(200), ctx.json(mockHostsResponse)),
-			),
-			rest.put(ZEUS_HOSTS_ENDPOINT, (_, res, ctx) =>
-				res(
-					ctx.status(409),
-					ctx.json({ error: { message: 'Already updated today' } }),
-				),
-			),
-		);
-
-		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		render(<CustomDomainSettings />);
-
-		await screen.findByText(/accepted-starfish\.test\.cloud/i);
-		await user.click(
-			screen.getByRole('button', { name: /customize team['’]s url/i }),
-		);
-		await user.type(screen.getByPlaceholderText(/enter domain/i), 'myteam');
-		await user.click(screen.getByRole('button', { name: /apply changes/i }));
-
-		expect(
-			await screen.findByRole('button', { name: /contact support/i }),
-		).toBeInTheDocument();
-	});
-});

frontend/src/container/DashboardContainer/visualization/components/ChartManager/ChartManager.styles.scss

@@ -1,22 +1,3 @@
-.chart-manager-series-label {
-	width: 100%;
-	min-width: 0;
-	max-width: 100%;
-	cursor: pointer;
-	border: none;
-	background-color: transparent;
-	color: inherit;
-	text-align: left;
-	padding: 0;
-	overflow: hidden;
-	text-overflow: ellipsis;
-	white-space: nowrap;
-
-	&:disabled {
-		cursor: not-allowed;
-	}
-}
-
 .chart-manager-container {
 	width: 100%;
 	max-height: calc(40% - 40px);

frontend/src/container/DashboardContainer/visualization/components/ChartManager/ChartManager.tsx

@@ -1,28 +1,24 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { Button, Input } from 'antd';
-import { PrecisionOption, PrecisionOptionsEnum } from 'components/Graph/types';
 import { ResizeTable } from 'components/ResizeTable';
+import { getGraphManagerTableColumns } from 'container/GridCardLayout/GridCard/FullView/TableRender/GraphManagerColumns';
+import { ExtendedChartDataset } from 'container/GridCardLayout/GridCard/FullView/types';
+import { getDefaultTableDataSet } from 'container/GridCardLayout/GridCard/FullView/utils';
 import { useNotifications } from 'hooks/useNotifications';
 import { UPlotConfigBuilder } from 'lib/uPlotV2/config/UPlotConfigBuilder';
 import { usePlotContext } from 'lib/uPlotV2/context/PlotContext';
 import useLegendsSync from 'lib/uPlotV2/hooks/useLegendsSync';
 import { useDashboard } from 'providers/Dashboard/Dashboard';
 
-import { getChartManagerColumns } from './columns';
-import { ExtendedChartDataset, getDefaultTableDataSet } from './utils';
-
 import './ChartManager.styles.scss';
 
 interface ChartManagerProps {
 	config: UPlotConfigBuilder;
 	alignedData: uPlot.AlignedData;
 	yAxisUnit?: string;
-	decimalPrecision?: PrecisionOption;
 	onCancel?: () => void;
 }
 
-const X_AXIS_INDEX = 0;
-
 /**
  * ChartManager provides a tabular view to manage the visibility of
  * individual series on a uPlot chart.
@@ -32,12 +28,16 @@ const X_AXIS_INDEX = 0;
  * - filter series by label
  * - toggle individual series on/off
  * - persist the visibility configuration to local storage.
+ *
+ * @param config - `UPlotConfigBuilder` instance used to derive chart options.
+ * @param alignedData - uPlot aligned data used to build the initial table dataset.
+ * @param yAxisUnit - Optional unit label for Y-axis values shown in the table.
+ * @param onCancel - Optional callback invoked when the user cancels the dialog.
  */
 export default function ChartManager({
 	config,
 	alignedData,
 	yAxisUnit,
-	decimalPrecision = PrecisionOptionsEnum.TWO,
 	onCancel,
 }: ChartManagerProps): JSX.Element {
 	const { notifications } = useNotifications();
@@ -53,13 +53,8 @@ export default function ChartManager({
 	const { isDashboardLocked } = useDashboard();
 
 	const [tableDataSet, setTableDataSet] = useState<ExtendedChartDataset[]>(() =>
-		getDefaultTableDataSet(
-			config.getConfig() as uPlot.Options,
-			alignedData,
-			decimalPrecision,
-		),
+		getDefaultTableDataSet(config.getConfig() as uPlot.Options, alignedData),
 	);
-	const [filterValue, setFilterValue] = useState('');
 
 	const graphVisibilityState = useMemo(
 		() =>
@@ -72,62 +67,46 @@ export default function ChartManager({
 
 	useEffect(() => {
 		setTableDataSet(
-			getDefaultTableDataSet(
-				config.getConfig() as uPlot.Options,
-				alignedData,
-				decimalPrecision,
-			),
+			getDefaultTableDataSet(config.getConfig() as uPlot.Options, alignedData),
 		);
-		setFilterValue('');
-	}, [alignedData, config, decimalPrecision]);
+	}, [alignedData, config]);
 
-	const handleFilterChange = useCallback(
-		(e: React.ChangeEvent<HTMLInputElement>): void => {
-			setFilterValue(e.target.value.toLowerCase());
+	const filterHandler = useCallback(
+		(event: React.ChangeEvent<HTMLInputElement>): void => {
+			const value = event.target.value.toString().toLowerCase();
+			const updatedDataSet = tableDataSet.map((item) => {
+				if (item.label?.toLocaleLowerCase().includes(value)) {
+					return { ...item, show: true };
+				}
+				return { ...item, show: false };
+			});
+			setTableDataSet(updatedDataSet);
 		},
-		[],
+		[tableDataSet],
 	);
 
-	const handleToggleSeriesOnOff = useCallback(
-		(index: number): void => {
-			onToggleSeriesOnOff(index);
-		},
-		[onToggleSeriesOnOff],
+	const dataSource = useMemo(
+		() =>
+			tableDataSet.filter(
+				(item, index) => index !== 0 && item.show, // skipping the first item as it is the x-axis
+			),
+		[tableDataSet],
 	);
 
-	const dataSource = useMemo(() => {
-		const filter = filterValue.trim();
-		return tableDataSet.filter((item, index) => {
-			if (index === X_AXIS_INDEX) {
-				return false;
-			}
-			if (!filter) {
-				return true;
-			}
-			return item.label?.toLowerCase().includes(filter) ?? false;
-		});
-	}, [tableDataSet, filterValue]);
-
 	const columns = useMemo(
 		() =>
-			getChartManagerColumns({
+			getGraphManagerTableColumns({
 				tableDataSet,
+				checkBoxOnChangeHandler: (_e, index) => {
+					onToggleSeriesOnOff(index);
+				},
 				graphVisibilityState,
-				onToggleSeriesOnOff: handleToggleSeriesOnOff,
-				onToggleSeriesVisibility,
+				labelClickedHandler: onToggleSeriesVisibility,
 				yAxisUnit,
 				isGraphDisabled: isDashboardLocked,
-				decimalPrecision,
 			}),
-		[
-			tableDataSet,
-			graphVisibilityState,
-			handleToggleSeriesOnOff,
-			onToggleSeriesVisibility,
-			yAxisUnit,
-			isDashboardLocked,
-			decimalPrecision,
-		],
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+		[tableDataSet, graphVisibilityState, yAxisUnit, isDashboardLocked],
 	);
 
 	const handleSave = useCallback((): void => {
@@ -135,23 +114,20 @@ export default function ChartManager({
 		notifications.success({
 			message: 'The updated graphs & legends are saved',
 		});
-		onCancel?.();
+		if (onCancel) {
+			onCancel();
+		}
 	}, [syncSeriesVisibilityToLocalStorage, notifications, onCancel]);
 
 	return (
 		<div className="chart-manager-container">
 			<div className="chart-manager-header">
-				<Input
-					placeholder="Filter Series"
-					value={filterValue}
-					onChange={handleFilterChange}
-					data-testid="filter-input"
-				/>
+				<Input onChange={filterHandler} placeholder="Filter Series" />
 				<div className="chart-manager-actions-container">
-					<Button type="default" onClick={onCancel} data-testid="cancel-button">
+					<Button type="default" onClick={onCancel}>
 						Cancel
 					</Button>
-					<Button type="primary" onClick={handleSave} data-testid="save-button">
+					<Button type="primary" onClick={handleSave}>
 						Save
 					</Button>
 				</div>
@@ -160,10 +136,10 @@ export default function ChartManager({
 				<ResizeTable
 					columns={columns}
 					dataSource={dataSource}
+					virtual
 					rowKey="index"
 					scroll={{ y: 200 }}
 					pagination={false}
-					virtual
 				/>
 			</div>
 		</div>

frontend/src/container/DashboardContainer/visualization/components/ChartManager/SeriesLabel.tsx

@@ -1,31 +0,0 @@
-import { Tooltip } from 'antd';
-
-import './ChartManager.styles.scss';
-
-interface SeriesLabelProps {
-	label: string;
-	labelIndex: number;
-	onClick: (idx: number) => void;
-	disabled?: boolean;
-}
-
-export function SeriesLabel({
-	label,
-	labelIndex,
-	onClick,
-	disabled,
-}: SeriesLabelProps): JSX.Element {
-	return (
-		<Tooltip placement="topLeft" title={label}>
-			<button
-				className="chart-manager-series-label"
-				disabled={disabled}
-				type="button"
-				data-testid={`series-label-button-${labelIndex}`}
-				onClick={(): void => onClick(labelIndex)}
-			>
-				{label}
-			</button>
-		</Tooltip>
-	);
-}

frontend/src/container/DashboardContainer/visualization/components/ChartManager/__tests__/ChartManager.test.tsx

@@ -1,172 +0,0 @@
-import userEvent from '@testing-library/user-event';
-import { UPlotConfigBuilder } from 'lib/uPlotV2/config/UPlotConfigBuilder';
-import { render, screen } from 'tests/test-utils';
-
-import ChartManager from '../ChartManager';
-
-const mockSyncSeriesVisibilityToLocalStorage = jest.fn();
-const mockNotificationsSuccess = jest.fn();
-
-jest.mock('lib/uPlotV2/context/PlotContext', () => ({
-	usePlotContext: (): {
-		onToggleSeriesOnOff: jest.Mock;
-		onToggleSeriesVisibility: jest.Mock;
-		syncSeriesVisibilityToLocalStorage: jest.Mock;
-	} => ({
-		onToggleSeriesOnOff: jest.fn(),
-		onToggleSeriesVisibility: jest.fn(),
-		syncSeriesVisibilityToLocalStorage: mockSyncSeriesVisibilityToLocalStorage,
-	}),
-}));
-
-jest.mock('lib/uPlotV2/hooks/useLegendsSync', () => ({
-	__esModule: true,
-	default: (): {
-		legendItemsMap: { [key: number]: { show: boolean; label: string } };
-	} => ({
-		legendItemsMap: {
-			0: { show: true, label: 'Time' },
-			1: { show: true, label: 'Series 1' },
-			2: { show: true, label: 'Series 2' },
-		},
-	}),
-}));
-
-jest.mock('providers/Dashboard/Dashboard', () => ({
-	useDashboard: (): { isDashboardLocked: boolean } => ({
-		isDashboardLocked: false,
-	}),
-}));
-
-jest.mock('hooks/useNotifications', () => ({
-	useNotifications: (): { notifications: { success: jest.Mock } } => ({
-		notifications: {
-			success: mockNotificationsSuccess,
-		},
-	}),
-}));
-
-jest.mock('components/ResizeTable', () => {
-	const MockTable = ({
-		dataSource,
-		columns,
-	}: {
-		dataSource: { index: number; label?: string }[];
-		columns: { key: string; title: string }[];
-	}): JSX.Element => (
-		<div data-testid="resize-table">
-			{columns.map((col) => (
-				<span key={col.key}>{col.title}</span>
-			))}
-			{dataSource.map((row) => (
-				<div key={row.index} data-testid={`row-${row.index}`}>
-					{row.label}
-				</div>
-			))}
-		</div>
-	);
-	return { ResizeTable: MockTable };
-});
-
-const createMockConfig = (): { getConfig: () => uPlot.Options } => ({
-	getConfig: (): uPlot.Options => ({
-		width: 100,
-		height: 100,
-		series: [
-			{ label: 'Time', value: 'time' },
-			{ label: 'Series 1', scale: 'y' },
-			{ label: 'Series 2', scale: 'y' },
-		],
-	}),
-});
-
-const createAlignedData = (): uPlot.AlignedData => [
-	[1000, 2000, 3000],
-	[10, 20, 30],
-	[1, 2, 3],
-];
-
-describe('ChartManager', () => {
-	const mockOnCancel = jest.fn();
-
-	beforeEach(() => {
-		jest.clearAllMocks();
-	});
-
-	it('renders filter input and action buttons', () => {
-		render(
-			<ChartManager
-				config={createMockConfig() as any}
-				alignedData={createAlignedData()}
-				onCancel={mockOnCancel}
-			/>,
-		);
-
-		expect(screen.getByPlaceholderText('Filter Series')).toBeInTheDocument();
-		expect(screen.getByRole('button', { name: /cancel/i })).toBeInTheDocument();
-		expect(screen.getByRole('button', { name: /save/i })).toBeInTheDocument();
-	});
-
-	it('renders ResizeTable with data', () => {
-		render(
-			<ChartManager
-				config={createMockConfig() as UPlotConfigBuilder}
-				alignedData={createAlignedData()}
-			/>,
-		);
-
-		expect(screen.getByTestId('resize-table')).toBeInTheDocument();
-	});
-
-	it('calls onCancel when Cancel button is clicked', async () => {
-		render(
-			<ChartManager
-				config={createMockConfig() as UPlotConfigBuilder}
-				alignedData={createAlignedData()}
-				onCancel={mockOnCancel}
-			/>,
-		);
-
-		await userEvent.click(screen.getByTestId('cancel-button'));
-
-		expect(mockOnCancel).toHaveBeenCalledTimes(1);
-	});
-
-	it('filters table data when typing in filter input', async () => {
-		render(
-			<ChartManager
-				config={createMockConfig() as UPlotConfigBuilder}
-				alignedData={createAlignedData()}
-			/>,
-		);
-
-		// Before filter: both Series 1 and Series 2 rows are visible
-		expect(screen.getByTestId('row-1')).toBeInTheDocument();
-		expect(screen.getByTestId('row-2')).toBeInTheDocument();
-
-		const filterInput = screen.getByTestId('filter-input');
-		await userEvent.type(filterInput, 'Series 1');
-
-		// After filter: only Series 1 row is visible, Series 2 row is filtered out
-		expect(screen.getByTestId('row-1')).toBeInTheDocument();
-		expect(screen.queryByTestId('row-2')).not.toBeInTheDocument();
-	});
-
-	it('calls syncSeriesVisibilityToLocalStorage, notifications.success, and onCancel when Save is clicked', async () => {
-		render(
-			<ChartManager
-				config={createMockConfig() as UPlotConfigBuilder}
-				alignedData={createAlignedData()}
-				onCancel={mockOnCancel}
-			/>,
-		);
-
-		await userEvent.click(screen.getByTestId('save-button'));
-
-		expect(mockSyncSeriesVisibilityToLocalStorage).toHaveBeenCalledTimes(1);
-		expect(mockNotificationsSuccess).toHaveBeenCalledWith({
-			message: 'The updated graphs & legends are saved',
-		});
-		expect(mockOnCancel).toHaveBeenCalledTimes(1);
-	});
-});

frontend/src/container/DashboardContainer/visualization/components/ChartManager/__tests__/SeriesLabel.test.tsx

@@ -1,39 +0,0 @@
-import userEvent from '@testing-library/user-event';
-import { render, screen } from 'tests/test-utils';
-
-import { SeriesLabel } from '../SeriesLabel';
-
-describe('SeriesLabel', () => {
-	it('renders the label text', () => {
-		render(
-			<SeriesLabel label="Test Series Label" labelIndex={1} onClick={jest.fn()} />,
-		);
-		expect(screen.getByTestId('series-label-button-1')).toHaveTextContent(
-			'Test Series Label',
-		);
-	});
-
-	it('calls onClick with labelIndex when clicked', async () => {
-		const onClick = jest.fn();
-		render(<SeriesLabel label="Series A" labelIndex={2} onClick={onClick} />);
-
-		await userEvent.click(screen.getByTestId('series-label-button-2'));
-
-		expect(onClick).toHaveBeenCalledWith(2);
-		expect(onClick).toHaveBeenCalledTimes(1);
-	});
-
-	it('renders disabled button when disabled prop is true', () => {
-		render(
-			<SeriesLabel label="Disabled" labelIndex={0} onClick={jest.fn()} disabled />,
-		);
-		const button = screen.getByTestId('series-label-button-0');
-		expect(button).toBeDisabled();
-	});
-
-	it('has chart-manager-series-label class', () => {
-		render(<SeriesLabel label="Label" labelIndex={0} onClick={jest.fn()} />);
-		const button = screen.getByTestId('series-label-button-0');
-		expect(button).toHaveClass('chart-manager-series-label');
-	});
-});

frontend/src/container/DashboardContainer/visualization/components/ChartManager/__tests__/columns.test.tsx

@@ -1,167 +0,0 @@
-import { render } from '@testing-library/react';
-import { Y_AXIS_UNIT_NAMES } from 'components/YAxisUnitSelector/constants';
-import { UniversalYAxisUnit } from 'components/YAxisUnitSelector/types';
-
-import { getChartManagerColumns } from '../columns';
-import { ExtendedChartDataset } from '../utils';
-
-const createMockDataset = (
-	index: number,
-	overrides: Partial<ExtendedChartDataset> = {},
-): ExtendedChartDataset =>
-	({
-		index,
-		label: `Series ${index}`,
-		show: true,
-		sum: 100,
-		avg: 50,
-		min: 10,
-		max: 90,
-		stroke: '#ff0000',
-		...overrides,
-	} as ExtendedChartDataset);
-
-describe('getChartManagerColumns', () => {
-	const tableDataSet: ExtendedChartDataset[] = [
-		createMockDataset(0, { label: 'Time' }),
-		createMockDataset(1),
-		createMockDataset(2),
-	];
-	const graphVisibilityState = [true, true, false];
-	const onToggleSeriesOnOff = jest.fn();
-	const onToggleSeriesVisibility = jest.fn();
-
-	beforeEach(() => {
-		jest.clearAllMocks();
-	});
-
-	it('returns columns with expected structure', () => {
-		const columns = getChartManagerColumns({
-			tableDataSet,
-			graphVisibilityState,
-			onToggleSeriesOnOff,
-			onToggleSeriesVisibility,
-		});
-
-		expect(columns).toHaveLength(6);
-		expect(columns[0].key).toBe('index');
-		expect(columns[1].key).toBe('label');
-		expect(columns[2].key).toBe('avg');
-		expect(columns[3].key).toBe('sum');
-		expect(columns[4].key).toBe('max');
-		expect(columns[5].key).toBe('min');
-	});
-
-	it('includes Label column with title', () => {
-		const columns = getChartManagerColumns({
-			tableDataSet,
-			graphVisibilityState,
-			onToggleSeriesOnOff,
-			onToggleSeriesVisibility,
-		});
-
-		const labelCol = columns.find((c) => c.key === 'label');
-		expect(labelCol?.title).toBe('Label');
-	});
-
-	it('formats column titles with yAxisUnit', () => {
-		const columns = getChartManagerColumns({
-			tableDataSet,
-			graphVisibilityState,
-			onToggleSeriesOnOff,
-			onToggleSeriesVisibility,
-			yAxisUnit: 'ms',
-		});
-
-		const avgCol = columns.find((c) => c.key === 'avg');
-		expect(avgCol?.title).toBe(
-			`Avg (in ${Y_AXIS_UNIT_NAMES[UniversalYAxisUnit.MILLISECONDS]})`,
-		);
-	});
-
-	it('numeric column render returns formatted string with yAxisUnit', () => {
-		const columns = getChartManagerColumns({
-			tableDataSet,
-			graphVisibilityState,
-			onToggleSeriesOnOff,
-			onToggleSeriesVisibility,
-			yAxisUnit: 'ms',
-		});
-
-		const avgCol = columns.find((c) => c.key === 'avg');
-		const renderFn = avgCol?.render as
-			| ((val: number, record: ExtendedChartDataset, index: number) => string)
-			| undefined;
-		expect(renderFn).toBeDefined();
-		const output = renderFn?.(123.45, tableDataSet[1], 1);
-		expect(output).toBe('123.45 ms');
-	});
-
-	it('numeric column render formats zero when value is undefined', () => {
-		const columns = getChartManagerColumns({
-			tableDataSet,
-			graphVisibilityState,
-			onToggleSeriesOnOff,
-			onToggleSeriesVisibility,
-			yAxisUnit: 'none',
-		});
-
-		const sumCol = columns.find((c) => c.key === 'sum');
-		const renderFn = sumCol?.render as
-			| ((
-					val: number | undefined,
-					record: ExtendedChartDataset,
-					index: number,
-			  ) => string)
-			| undefined;
-		const output = renderFn?.(undefined, tableDataSet[1], 1);
-		expect(output).toBe('0');
-	});
-
-	it('label column render displays label text and is clickable', () => {
-		const columns = getChartManagerColumns({
-			tableDataSet,
-			graphVisibilityState,
-			onToggleSeriesOnOff,
-			onToggleSeriesVisibility,
-		});
-
-		const labelCol = columns.find((c) => c.key === 'label');
-		const renderFn = labelCol?.render as
-			| ((
-					label: string,
-					record: ExtendedChartDataset,
-					index: number,
-			  ) => JSX.Element)
-			| undefined;
-		expect(renderFn).toBeDefined();
-		const renderResult = renderFn!('Series 1', tableDataSet[1], 1);
-
-		const { getByRole } = render(renderResult);
-		expect(getByRole('button', { name: 'Series 1' })).toBeInTheDocument();
-	});
-
-	it('index column render renders checkbox with correct checked state', () => {
-		const columns = getChartManagerColumns({
-			tableDataSet,
-			graphVisibilityState,
-			onToggleSeriesOnOff,
-			onToggleSeriesVisibility,
-		});
-
-		const indexCol = columns.find((c) => c.key === 'index');
-		const renderFn = indexCol?.render as
-			| ((
-					_val: unknown,
-					record: ExtendedChartDataset,
-					index: number,
-			  ) => JSX.Element)
-			| undefined;
-		expect(renderFn).toBeDefined();
-		const { container } = render(renderFn!(null, tableDataSet[1], 1));
-
-		const checkbox = container.querySelector('input[type="checkbox"]');
-		expect(checkbox).toBeInTheDocument();
-		expect(checkbox).toBeChecked(); // graphVisibilityState[1] is true
-	});
-});

frontend/src/container/DashboardContainer/visualization/components/ChartManager/__tests__/utils.test.ts

@@ -1,113 +0,0 @@
-import { PrecisionOptionsEnum } from 'components/Graph/types';
-
-import {
-	formatTableValueWithUnit,
-	getDefaultTableDataSet,
-	getTableColumnTitle,
-} from '../utils';
-
-describe('ChartManager utils', () => {
-	describe('getDefaultTableDataSet', () => {
-		const createOptions = (seriesCount: number): uPlot.Options => ({
-			series: Array.from({ length: seriesCount }, (_, i) =>
-				i === 0
-					? { label: 'Time', value: 'time' }
-					: { label: `Series ${i}`, scale: 'y' },
-			),
-			width: 100,
-			height: 100,
-		});
-
-		it('returns one row per series with computed stats', () => {
-			const options = createOptions(3);
-			const data: uPlot.AlignedData = [
-				[1000, 2000, 3000],
-				[10, 20, 30],
-				[1, 2, 3],
-			];
-
-			const result = getDefaultTableDataSet(options, data);
-
-			expect(result).toHaveLength(3);
-			expect(result[0]).toMatchObject({
-				index: 0,
-				label: 'Time',
-				show: true,
-			});
-			expect(result[1]).toMatchObject({
-				index: 1,
-				label: 'Series 1',
-				show: true,
-				sum: 60,
-				avg: 20,
-				max: 30,
-				min: 10,
-			});
-			expect(result[2]).toMatchObject({
-				index: 2,
-				label: 'Series 2',
-				show: true,
-				sum: 6,
-				avg: 2,
-				max: 3,
-				min: 1,
-			});
-		});
-
-		it('handles empty data arrays', () => {
-			const options = createOptions(2);
-			const data: uPlot.AlignedData = [[], []];
-
-			const result = getDefaultTableDataSet(options, data);
-
-			expect(result[0]).toMatchObject({
-				sum: 0,
-				avg: 0,
-				max: 0,
-				min: 0,
-			});
-		});
-
-		it('respects decimalPrecision parameter', () => {
-			const options = createOptions(2);
-			const data: uPlot.AlignedData = [[1000], [123.454]];
-
-			const resultTwo = getDefaultTableDataSet(
-				options,
-				data,
-				PrecisionOptionsEnum.TWO,
-			);
-			expect(resultTwo[1].avg).toBe(123.45);
-
-			const resultZero = getDefaultTableDataSet(
-				options,
-				data,
-				PrecisionOptionsEnum.ZERO,
-			);
-			expect(resultZero[1].avg).toBe(123);
-		});
-	});
-
-	describe('formatTableValueWithUnit', () => {
-		it('formats value with unit', () => {
-			const result = formatTableValueWithUnit(1234.56, 'ms');
-			expect(result).toBe('1.23 s');
-		});
-
-		it('falls back to none format when yAxisUnit is undefined', () => {
-			const result = formatTableValueWithUnit(123.45);
-			expect(result).toBe('123.45');
-		});
-	});
-
-	describe('getTableColumnTitle', () => {
-		it('returns title only when yAxisUnit is undefined', () => {
-			expect(getTableColumnTitle('Avg')).toBe('Avg');
-		});
-
-		it('returns title with unit when yAxisUnit is provided', () => {
-			const result = getTableColumnTitle('Avg', 'ms');
-			expect(result).toBe('Avg (in Milliseconds (ms))');
-		});
-	});
-});

frontend/src/container/DashboardContainer/visualization/components/ChartManager/columns.tsx

@@ -1,94 +0,0 @@
-import { ColumnType } from 'antd/es/table';
-import { PrecisionOption, PrecisionOptionsEnum } from 'components/Graph/types';
-import CustomCheckBox from 'container/GridCardLayout/GridCard/FullView/TableRender/CustomCheckBox';
-
-import { SeriesLabel } from './SeriesLabel';
-import {
-	ExtendedChartDataset,
-	formatTableValueWithUnit,
-	getTableColumnTitle,
-} from './utils';
-
-export interface GetChartManagerColumnsParams {
-	tableDataSet: ExtendedChartDataset[];
-	graphVisibilityState: boolean[];
-	onToggleSeriesOnOff: (index: number) => void;
-	onToggleSeriesVisibility: (index: number) => void;
-	yAxisUnit?: string;
-	decimalPrecision?: PrecisionOption;
-	isGraphDisabled?: boolean;
-}
-
-export function getChartManagerColumns({
-	tableDataSet,
-	graphVisibilityState,
-	onToggleSeriesOnOff,
-	onToggleSeriesVisibility,
-	yAxisUnit,
-	decimalPrecision = PrecisionOptionsEnum.TWO,
-	isGraphDisabled,
-}: GetChartManagerColumnsParams): ColumnType<ExtendedChartDataset>[] {
-	return [
-		{
-			title: '',
-			width: 50,
-			dataIndex: 'index',
-			key: 'index',
-			render: (_: unknown, record: ExtendedChartDataset): JSX.Element => (
-				<CustomCheckBox
-					data={tableDataSet}
-					graphVisibilityState={graphVisibilityState}
-					index={record.index}
-					disabled={isGraphDisabled}
-					checkBoxOnChangeHandler={(_e, idx): void => onToggleSeriesOnOff(idx)}
-				/>
-			),
-		},
-		{
-			title: 'Label',
-			width: 300,
-			dataIndex: 'label',
-			key: 'label',
-			render: (label: string, record: ExtendedChartDataset): JSX.Element => (
-				<SeriesLabel
-					label={label ?? ''}
-					labelIndex={record.index}
-					disabled={isGraphDisabled}
-					onClick={onToggleSeriesVisibility}
-				/>
-			),
-		},
-		{
-			title: getTableColumnTitle('Avg', yAxisUnit),
-			width: 90,
-			dataIndex: 'avg',
-			key: 'avg',
-			render: (val: number | undefined): string =>
-				formatTableValueWithUnit(val ?? 0, yAxisUnit, decimalPrecision),
-		},
-		{
-			title: getTableColumnTitle('Sum', yAxisUnit),
-			width: 90,
-			dataIndex: 'sum',
-			key: 'sum',
-			render: (val: number | undefined): string =>
-				formatTableValueWithUnit(val ?? 0, yAxisUnit, decimalPrecision),
-		},
-		{
-			title: getTableColumnTitle('Max', yAxisUnit),
-			width: 90,
-			dataIndex: 'max',
-			key: 'max',
-			render: (val: number | undefined): string =>
-				formatTableValueWithUnit(val ?? 0, yAxisUnit, decimalPrecision),
-		},
-		{
-			title: getTableColumnTitle('Min', yAxisUnit),
-			width: 90,
-			dataIndex: 'min',
-			key: 'min',
-			render: (val: number | undefined): string =>
-				formatTableValueWithUnit(val ?? 0, yAxisUnit, decimalPrecision),
-		},
-	];
-}

frontend/src/container/DashboardContainer/visualization/components/ChartManager/utils.ts

@@ -1,93 +0,0 @@
-import { PrecisionOption, PrecisionOptionsEnum } from 'components/Graph/types';
-import { getYAxisFormattedValue } from 'components/Graph/yAxisConfig';
-import { Y_AXIS_UNIT_NAMES } from 'components/YAxisUnitSelector/constants';
-import uPlot from 'uplot';
-
-/** Extended series with computed stats for table display */
-export type ExtendedChartDataset = uPlot.Series & {
-	show: boolean;
-	sum: number;
-	avg: number;
-	min: number;
-	max: number;
-	index: number;
-};
-
-function roundToDecimalPrecision(
-	value: number,
-	decimalPrecision: PrecisionOption = PrecisionOptionsEnum.TWO,
-): number {
-	if (
-		typeof value !== 'number' ||
-		Number.isNaN(value) ||
-		value === Infinity ||
-		value === -Infinity
-	) {
-		return 0;
-	}
-
-	if (decimalPrecision === PrecisionOptionsEnum.FULL) {
-		return value;
-	}
-
-	// regex to match the decimal precision for the given decimal precision
-	const regex = new RegExp(`^-?\\d*\\.?0*\\d{0,${decimalPrecision}}`);
-	const matched = value ? value.toFixed(decimalPrecision).match(regex) : null;
-	return matched ? parseFloat(matched[0]) : 0;
-}
-
-/** Build table dataset from uPlot options and aligned data */
-export function getDefaultTableDataSet(
-	options: uPlot.Options,
-	data: uPlot.AlignedData,
-	decimalPrecision: PrecisionOption = PrecisionOptionsEnum.TWO,
-): ExtendedChartDataset[] {
-	return options.series.map(
-		(series: uPlot.Series, index: number): ExtendedChartDataset => {
-			const arr = (data[index] as number[]) ?? [];
-			const sum = arr.reduce((a, b) => a + b, 0) || 0;
-			const count = arr.length || 1;
-
-			const hasValues = arr.length > 0;
-			return {
-				...series,
-				index,
-				show: true,
-				sum: roundToDecimalPrecision(sum, decimalPrecision),
-				avg: roundToDecimalPrecision(sum / count, decimalPrecision),
-				max: hasValues
-					? roundToDecimalPrecision(Math.max(...arr), decimalPrecision)
-					: 0,
-				min: hasValues
-					? roundToDecimalPrecision(Math.min(...arr), decimalPrecision)
-					: 0,
-			};
-		},
-	);
-}
-
-/** Format numeric value for table display using yAxisUnit */
-export function formatTableValueWithUnit(
-	value: number,
-	yAxisUnit?: string,
-	decimalPrecision: PrecisionOption = PrecisionOptionsEnum.TWO,
-): string {
-	return `${getYAxisFormattedValue(
-		String(value),
-		yAxisUnit ?? 'none',
-		decimalPrecision,
-	)}`;
-}
-
-/** Format column header with optional unit */
-export function getTableColumnTitle(title: string, yAxisUnit?: string): string {
-	if (!yAxisUnit) {
-		return title;
-	}
-	const universalName =
-		Y_AXIS_UNIT_NAMES[yAxisUnit as keyof typeof Y_AXIS_UNIT_NAMES];
-	if (!universalName) {
-		return `${title} (in ${yAxisUnit})`;
-	}
-	return `${title} (in ${universalName})`;
-}

frontend/src/container/DashboardContainer/visualization/panels/BarPanel/BarPanel.tsx

@@ -96,7 +96,6 @@ function BarPanel(props: PanelWrapperProps): JSX.Element {
 				config={config}
 				alignedData={chartData}
 				yAxisUnit={widget.yAxisUnit}
-				decimalPrecision={widget.decimalPrecision}
 				onCancel={onToggleModelHandler}
 			/>
 		);
@@ -106,7 +105,6 @@ function BarPanel(props: PanelWrapperProps): JSX.Element {
 		chartData,
 		widget.yAxisUnit,
 		onToggleModelHandler,
-		widget.decimalPrecision,
 	]);
 
 	const onPlotDestroy = useCallback(() => {

frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/TimeSeriesPanel.tsx

@@ -95,7 +95,6 @@ function TimeSeriesPanel(props: PanelWrapperProps): JSX.Element {
 				config={config}
 				alignedData={chartData}
 				yAxisUnit={widget.yAxisUnit}
-				decimalPrecision={widget.decimalPrecision}
 				onCancel={onToggleModelHandler}
 			/>
 		);
@@ -105,7 +104,6 @@ function TimeSeriesPanel(props: PanelWrapperProps): JSX.Element {
 		chartData,
 		widget.yAxisUnit,
 		onToggleModelHandler,
-		widget.decimalPrecision,
 	]);
 
 	return (

frontend/src/container/Home/DataSourceInfo/DataSourceInfo.tsx

@@ -2,10 +2,10 @@
 import { useEffect, useState } from 'react';
 import { Button, Skeleton, Tag, Typography } from 'antd';
 import logEvent from 'api/common/logEvent';
-import { useGetHosts } from 'api/generated/services/zeus';
 import ROUTES from 'constants/routes';
+import { useGetDeploymentsData } from 'hooks/CustomDomain/useGetDeploymentsData';
 import history from 'lib/history';
-import { Link2 } from 'lucide-react';
+import { Globe, Link2 } from 'lucide-react';
 import Card from 'periscope/components/Card/Card';
 import { useAppContext } from 'providers/App/App';
 import { LicensePlatform } from 'types/api/licensesV3/getActive';
@@ -26,21 +26,36 @@ function DataSourceInfo({
 	const isEnabled =
 		activeLicense && activeLicense.platform === LicensePlatform.CLOUD;
 
-	const { data: hostsData, isError } = useGetHosts({
-		query: { enabled: isEnabled || false },
-	});
+	const {
+		data: deploymentsData,
+		isError: isErrorDeploymentsData,
+	} = useGetDeploymentsData(isEnabled || false);
 
+	const [region, setRegion] = useState<string>('');
 	const [url, setUrl] = useState<string>('');
 
 	useEffect(() => {
-		if (hostsData) {
-			const defaultHost = hostsData?.data?.data?.hosts?.find((h) => h.is_default);
-			if (defaultHost?.url) {
-				const url = defaultHost?.url?.split('://')[1] ?? '';
-				setUrl(url);
+		if (deploymentsData) {
+			switch (deploymentsData?.data.data.cluster.region.name) {
+				case 'in':
+					setRegion('India');
+					break;
+				case 'us':
+					setRegion('United States');
+					break;
+				case 'eu':
+					setRegion('Europe');
+					break;
+				default:
+					setRegion(deploymentsData?.data.data.cluster.region.name);
+					break;
 			}
+
+			setUrl(
+				`${deploymentsData?.data.data.name}.${deploymentsData?.data.data.cluster.region.dns}`,
+			);
 		}
-	}, [hostsData]);
+	}, [deploymentsData]);
 
 	const renderNotSendingData = (): JSX.Element => (
 		<>
@@ -108,8 +123,14 @@ function DataSourceInfo({
 							</Button>
 						</div>
 
-						{!isError && hostsData && (
+						{!isErrorDeploymentsData && deploymentsData && (
 							<div className="workspace-details">
+								<div className="workspace-region">
+									<Globe size={10} />
+
+									<Typography>{region}</Typography>
+								</div>
+
 								<div className="workspace-url">
 									<Link2 size={12} />
 
@@ -135,11 +156,17 @@ function DataSourceInfo({
 				Hello there, Welcome to your SigNoz workspace
 			</Typography>
 
-			{!isError && hostsData && (
+			{!isErrorDeploymentsData && deploymentsData && (
 				<Card className="welcome-card">
 					<Card.Content>
 						<div className="workspace-ready-container">
 							<div className="workspace-details">
+								<div className="workspace-region">
+									<Globe size={10} />
+
+									<Typography>{region}</Typography>
+								</div>
+
 								<div className="workspace-url">
 									<Link2 size={12} />
 

frontend/src/container/Home/DataSourceInfo/__tests__/DataSourceInfo.test.tsx

@@ -1,69 +0,0 @@
-import { GetHosts200 } from 'api/generated/services/sigNoz.schemas';
-import { rest, server } from 'mocks-server/server';
-import { render, screen } from 'tests/test-utils';
-
-import DataSourceInfo from '../DataSourceInfo';
-
-const ZEUS_HOSTS_ENDPOINT = '*/api/v2/zeus/hosts';
-
-const mockHostsResponse: GetHosts200 = {
-	status: 'success',
-	data: {
-		name: 'accepted-starfish',
-		state: 'HEALTHY',
-		tier: 'PREMIUM',
-		hosts: [
-			{
-				name: 'accepted-starfish',
-				is_default: true,
-				url: 'https://accepted-starfish.test.cloud',
-			},
-			{
-				name: 'custom-host',
-				is_default: false,
-				url: 'https://custom-host.test.cloud',
-			},
-		],
-	},
-};
-
-describe('DataSourceInfo', () => {
-	afterEach(() => server.resetHandlers());
-
-	it('renders the default workspace URL with protocol stripped', async () => {
-		server.use(
-			rest.get(ZEUS_HOSTS_ENDPOINT, (_, res, ctx) =>
-				res(ctx.status(200), ctx.json(mockHostsResponse)),
-			),
-		);
-
-		render(<DataSourceInfo dataSentToSigNoz={false} isLoading={false} />);
-
-		await screen.findByText(/accepted-starfish\.test\.cloud/i);
-	});
-
-	it('does not render workspace URL when GET /zeus/hosts fails', async () => {
-		server.use(
-			rest.get(ZEUS_HOSTS_ENDPOINT, (_, res, ctx) =>
-				res(ctx.status(500), ctx.json({})),
-			),
-		);
-
-		render(<DataSourceInfo dataSentToSigNoz={false} isLoading={false} />);
-
-		await screen.findByText(/Your workspace is ready/i);
-		expect(screen.queryByText(/signoz\.cloud/i)).not.toBeInTheDocument();
-	});
-
-	it('renders workspace URL in the data-received view when telemetry is flowing', async () => {
-		server.use(
-			rest.get(ZEUS_HOSTS_ENDPOINT, (_, res, ctx) =>
-				res(ctx.status(200), ctx.json(mockHostsResponse)),
-			),
-		);
-
-		render(<DataSourceInfo dataSentToSigNoz={true} isLoading={false} />);
-
-		await screen.findByText(/accepted-starfish\.test\.cloud/i);
-	});
-});

frontend/src/container/InfraMonitoringHosts/HostsListTable.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useMemo } from 'react';
+import React, { useCallback, useMemo } from 'react';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Skeleton,
@@ -14,12 +14,93 @@ import { InfraMonitoringEvents } from 'constants/events';
 
 import HostsEmptyOrIncorrectMetrics from './HostsEmptyOrIncorrectMetrics';
 import {
+	EmptyOrLoadingViewProps,
 	formatDataForTable,
 	getHostsListColumns,
 	HostRowData,
 	HostsListTableProps,
 } from './utils';
 
+function EmptyOrLoadingView(
+	viewState: EmptyOrLoadingViewProps,
+): React.ReactNode {
+	const { isError, errorMessage } = viewState;
+	if (isError) {
+		return <Typography>{errorMessage || 'Something went wrong'}</Typography>;
+	}
+	if (viewState.showHostsEmptyState) {
+		return (
+			<HostsEmptyOrIncorrectMetrics
+				noData={!viewState.sentAnyHostMetricsData}
+				incorrectData={viewState.isSendingIncorrectK8SAgentMetrics}
+			/>
+		);
+	}
+	if (viewState.showEndTimeBeforeRetentionMessage) {
+		return (
+			<div className="hosts-empty-state-container">
+				<div className="hosts-empty-state-container-content">
+					<img className="eyes-emoji" src="/Images/eyesEmoji.svg" alt="eyes emoji" />
+					<div className="no-hosts-message">
+						<Typography.Title level={5} className="no-hosts-message-title">
+							Queried time range is before earliest host metrics
+						</Typography.Title>
+						<Typography.Text className="no-hosts-message-text">
+							Your requested end time is earlier than the earliest detected time of
+							host metrics data, please adjust your end time.
+						</Typography.Text>
+					</div>
+				</div>
+			</div>
+		);
+	}
+	if (viewState.showNoRecordsInSelectedTimeRangeMessage) {
+		return (
+			<div className="no-filtered-hosts-message-container">
+				<div className="no-filtered-hosts-message-content">
+					<img
+						src="/Icons/emptyState.svg"
+						alt="thinking-emoji"
+						className="empty-state-svg"
+					/>
+					<Typography.Title level={5} className="no-filtered-hosts-title">
+						No host metrics found
+					</Typography.Title>
+					<Typography.Text className="no-filtered-hosts-message">
+						No host metrics in the selected time range and filters. Please adjust your
+						time range or filters.
+					</Typography.Text>
+				</div>
+			</div>
+		);
+	}
+	if (viewState.showTableLoadingState) {
+		return (
+			<div className="hosts-list-loading-state">
+				<Skeleton.Input
+					className="hosts-list-loading-state-item"
+					size="large"
+					block
+					active
+				/>
+				<Skeleton.Input
+					className="hosts-list-loading-state-item"
+					size="large"
+					block
+					active
+				/>
+				<Skeleton.Input
+					className="hosts-list-loading-state-item"
+					size="large"
+					block
+					active
+				/>
+			</div>
+		);
+	}
+	return null;
+}
+
 export default function HostsListTable({
 	isLoading,
 	isFetching,
@@ -46,6 +127,11 @@ export default function HostsListTable({
 		[data],
 	);
 
+	const endTimeBeforeRetention = useMemo(
+		() => data?.payload?.data?.endTimeBeforeRetention || false,
+		[data],
+	);
+
 	const formattedHostMetricsData = useMemo(
 		() => formatDataForTable(hostMetricsData),
 		[hostMetricsData],
@@ -84,12 +170,6 @@ export default function HostsListTable({
 		});
 	};
 
-	const showNoFilteredHostsMessage =
-		!isFetching &&
-		!isLoading &&
-		formattedHostMetricsData.length === 0 &&
-		filters.items.length > 0;
-
 	const showHostsEmptyState =
 		!isFetching &&
 		!isLoading &&
@@ -97,63 +177,36 @@ export default function HostsListTable({
 		(!sentAnyHostMetricsData || isSendingIncorrectK8SAgentMetrics) &&
 		!filters.items.length;
 
+	const showEndTimeBeforeRetentionMessage =
+		!isFetching &&
+		!isLoading &&
+		formattedHostMetricsData.length === 0 &&
+		endTimeBeforeRetention &&
+		!filters.items.length;
+
+	const showNoRecordsInSelectedTimeRangeMessage =
+		!isFetching &&
+		!isLoading &&
+		formattedHostMetricsData.length === 0 &&
+		!showEndTimeBeforeRetentionMessage &&
+		!showHostsEmptyState;
+
 	const showTableLoadingState =
 		(isLoading || isFetching) && formattedHostMetricsData.length === 0;
 
-	if (isError) {
-		return <Typography>{data?.error || 'Something went wrong'}</Typography>;
-	}
+	const emptyOrLoadingView = EmptyOrLoadingView({
+		isError,
+		errorMessage: data?.error ?? '',
+		showHostsEmptyState,
+		sentAnyHostMetricsData,
+		isSendingIncorrectK8SAgentMetrics,
+		showEndTimeBeforeRetentionMessage,
+		showNoRecordsInSelectedTimeRangeMessage,
+		showTableLoadingState,
+	});
 
-	if (showHostsEmptyState) {
-		return (
-			<HostsEmptyOrIncorrectMetrics
-				noData={!sentAnyHostMetricsData}
-				incorrectData={isSendingIncorrectK8SAgentMetrics}
-			/>
-		);
-	}
-
-	if (showNoFilteredHostsMessage) {
-		return (
-			<div className="no-filtered-hosts-message-container">
-				<div className="no-filtered-hosts-message-content">
-					<img
-						src="/Icons/emptyState.svg"
-						alt="thinking-emoji"
-						className="empty-state-svg"
-					/>
-
-					<Typography.Text className="no-filtered-hosts-message">
-						This query had no results. Edit your query and try again!
-					</Typography.Text>
-				</div>
-			</div>
-		);
-	}
-
-	if (showTableLoadingState) {
-		return (
-			<div className="hosts-list-loading-state">
-				<Skeleton.Input
-					className="hosts-list-loading-state-item"
-					size="large"
-					block
-					active
-				/>
-				<Skeleton.Input
-					className="hosts-list-loading-state-item"
-					size="large"
-					block
-					active
-				/>
-				<Skeleton.Input
-					className="hosts-list-loading-state-item"
-					size="large"
-					block
-					active
-				/>
-			</div>
-		);
+	if (emptyOrLoadingView) {
+		return <>{emptyOrLoadingView}</>;
 	}
 
 	return (

frontend/src/container/InfraMonitoringHosts/__tests__/HostsListTable.test.tsx

@@ -1,12 +1,16 @@
 /* eslint-disable react/jsx-props-no-spreading */
 import { render, screen } from '@testing-library/react';
+import { HostData, HostListResponse } from 'api/infraMonitoring/getHostLists';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
 
 import HostsListTable from '../HostsListTable';
+import { HostsListTableProps } from '../utils';
 
 const EMPTY_STATE_CONTAINER_CLASS = '.hosts-empty-state-container';
 
-describe('HostsListTable', () => {
-	const mockHost = {
+const createMockHost = (): HostData =>
+	({
 		hostName: 'test-host-1',
 		active: true,
 		cpu: 0.75,
@@ -14,20 +18,46 @@ describe('HostsListTable', () => {
 		wait: 0.03,
 		load15: 1.5,
 		os: 'linux',
-	};
+		cpuTimeSeries: { labels: {}, labelsArray: [], values: [] },
+		memoryTimeSeries: { labels: {}, labelsArray: [], values: [] },
+		waitTimeSeries: { labels: {}, labelsArray: [], values: [] },
+		load15TimeSeries: { labels: {}, labelsArray: [], values: [] },
+	} as HostData);
 
-	const mockTableData = {
+const createMockTableData = (
+	overrides: Partial<HostListResponse['data']> = {},
+): SuccessResponse<HostListResponse> => {
+	const mockHost = createMockHost();
+	return {
+		statusCode: 200,
+		message: 'Success',
+		error: null,
 		payload: {
+			status: 'success',
 			data: {
-				hosts: [mockHost],
+				type: 'list',
+				records: [mockHost],
+				groups: null,
+				total: 1,
+				sentAnyHostMetricsData: true,
+				isSendingK8SAgentMetrics: false,
+				endTimeBeforeRetention: false,
+				...overrides,
 			},
 		},
 	};
+};
+
+describe('HostsListTable', () => {
+	const mockHost = createMockHost();
+	const mockTableData = createMockTableData();
+
 	const mockOnHostClick = jest.fn();
 	const mockSetCurrentPage = jest.fn();
 	const mockSetOrderBy = jest.fn();
 	const mockSetPageSize = jest.fn();
-	const mockProps = {
+
+	const mockProps: HostsListTableProps = {
 		isLoading: false,
 		isError: false,
 		isFetching: false,
@@ -43,7 +73,7 @@ describe('HostsListTable', () => {
 		pageSize: 10,
 		setOrderBy: mockSetOrderBy,
 		setPageSize: mockSetPageSize,
-	} as any;
+	};
 
 	it('renders loading state if isLoading is true and tableData is empty', () => {
 		const { container } = render(
@@ -51,7 +81,7 @@ describe('HostsListTable', () => {
 				{...mockProps}
 				isLoading
 				hostMetricsData={[]}
-				tableData={{ payload: { data: { hosts: [] } } }}
+				tableData={createMockTableData({ records: [] })}
 			/>,
 		);
 		expect(container.querySelector('.hosts-list-loading-state')).toBeTruthy();
@@ -63,7 +93,7 @@ describe('HostsListTable', () => {
 				{...mockProps}
 				isFetching
 				hostMetricsData={[]}
-				tableData={{ payload: { data: { hosts: [] } } }}
+				tableData={createMockTableData({ records: [] })}
 			/>,
 		);
 		expect(container.querySelector('.hosts-list-loading-state')).toBeTruthy();
@@ -74,19 +104,56 @@ describe('HostsListTable', () => {
 		expect(screen.getByText('Something went wrong')).toBeTruthy();
 	});
 
+	it('renders "Something went wrong" fallback when isError is true and error message is empty', () => {
+		const tableDataWithEmptyError: ErrorResponse = {
+			statusCode: 500,
+			payload: null,
+			error: '',
+			message: null,
+		};
+		render(
+			<HostsListTable
+				{...mockProps}
+				isError
+				hostMetricsData={[]}
+				tableData={tableDataWithEmptyError}
+			/>,
+		);
+		expect(screen.getByText('Something went wrong')).toBeInTheDocument();
+	});
+
+	it('renders custom error message when isError is true and error message is provided', () => {
+		const customErrorMessage = 'Failed to fetch host metrics';
+		const tableDataWithError: ErrorResponse = {
+			statusCode: 500,
+			payload: null,
+			error: customErrorMessage,
+			message: null,
+		};
+		render(
+			<HostsListTable
+				{...mockProps}
+				isError
+				hostMetricsData={[]}
+				tableData={tableDataWithError}
+			/>,
+		);
+		expect(screen.getByText(customErrorMessage)).toBeInTheDocument();
+	});
+
 	it('renders empty state if no hosts are found', () => {
 		const { container } = render(
 			<HostsListTable
 				{...mockProps}
 				hostMetricsData={[]}
-				tableData={{
-					payload: {
-						data: { hosts: [] },
-					},
-				}}
+				tableData={createMockTableData({
+					records: [],
+				})}
 			/>,
 		);
-		expect(container.querySelector(EMPTY_STATE_CONTAINER_CLASS)).toBeTruthy();
+		expect(
+			container.querySelector('.no-filtered-hosts-message-container'),
+		).toBeTruthy();
 	});
 
 	it('renders empty state if sentAnyHostMetricsData is false', () => {
@@ -94,58 +161,114 @@ describe('HostsListTable', () => {
 			<HostsListTable
 				{...mockProps}
 				hostMetricsData={[]}
-				tableData={{
-					...mockTableData,
-					payload: {
-						...mockTableData.payload,
-						data: {
-							...mockTableData.payload.data,
-							sentAnyHostMetricsData: false,
-							hosts: [],
-						},
-					},
-				}}
+				tableData={createMockTableData({
+					sentAnyHostMetricsData: false,
+					records: [],
+				})}
 			/>,
 		);
 		expect(container.querySelector(EMPTY_STATE_CONTAINER_CLASS)).toBeTruthy();
 	});
 
-	it('renders empty state if isSendingIncorrectK8SAgentMetrics is true', () => {
+	it('renders empty state if isSendingK8SAgentMetrics is true', () => {
 		const { container } = render(
 			<HostsListTable
 				{...mockProps}
 				hostMetricsData={[]}
-				tableData={{
-					...mockTableData,
-					payload: {
-						...mockTableData.payload,
-						data: {
-							...mockTableData.payload.data,
-							isSendingIncorrectK8SAgentMetrics: true,
-							hosts: [],
-						},
-					},
-				}}
+				tableData={createMockTableData({
+					isSendingK8SAgentMetrics: true,
+					records: [],
+				})}
 			/>,
 		);
 		expect(container.querySelector(EMPTY_STATE_CONTAINER_CLASS)).toBeTruthy();
 	});
 
+	it('renders end time before retention message when endTimeBeforeRetention is true', () => {
+		const { container } = render(
+			<HostsListTable
+				{...mockProps}
+				hostMetricsData={[]}
+				tableData={createMockTableData({
+					sentAnyHostMetricsData: true,
+					isSendingK8SAgentMetrics: false,
+					endTimeBeforeRetention: true,
+					records: [],
+				})}
+			/>,
+		);
+		expect(container.querySelector(EMPTY_STATE_CONTAINER_CLASS)).toBeTruthy();
+		expect(
+			screen.getByText(
+				/Your requested end time is earlier than the earliest detected time of host metrics data, please adjust your end time\./,
+			),
+		).toBeInTheDocument();
+	});
+
+	it('renders no records message when noRecordsInSelectedTimeRangeAndFilters is true', () => {
+		const { container } = render(
+			<HostsListTable
+				{...mockProps}
+				hostMetricsData={[]}
+				tableData={createMockTableData({
+					sentAnyHostMetricsData: true,
+					isSendingK8SAgentMetrics: false,
+					records: [],
+				})}
+			/>,
+		);
+		expect(
+			container.querySelector('.no-filtered-hosts-message-container'),
+		).toBeTruthy();
+		expect(
+			screen.getByText(/No host metrics in the selected time range and filters/),
+		).toBeInTheDocument();
+	});
+
+	it('renders no filtered hosts message when filters are present and no hosts are found', () => {
+		const { container } = render(
+			<HostsListTable
+				{...mockProps}
+				hostMetricsData={[]}
+				filters={{
+					items: [
+						{
+							id: 'host_name',
+							key: {
+								key: 'host_name',
+								dataType: DataTypes.String,
+								type: 'tag',
+								isIndexed: true,
+							},
+							op: '=',
+							value: 'unknown',
+						},
+					],
+					op: 'AND',
+				}}
+				tableData={createMockTableData({
+					sentAnyHostMetricsData: true,
+					isSendingK8SAgentMetrics: false,
+					records: [],
+				})}
+			/>,
+		);
+		expect(container.querySelector('.no-filtered-hosts-message')).toBeTruthy();
+		expect(
+			screen.getByText(
+				/No host metrics in the selected time range and filters\. Please adjust your time range or filters\./,
+			),
+		).toBeInTheDocument();
+	});
+
 	it('renders table data', () => {
 		const { container } = render(
 			<HostsListTable
 				{...mockProps}
-				tableData={{
-					...mockTableData,
-					payload: {
-						...mockTableData.payload,
-						data: {
-							...mockTableData.payload.data,
-							isSendingIncorrectK8SAgentMetrics: false,
-							sentAnyHostMetricsData: true,
-						},
-					},
-				}}
+				tableData={createMockTableData({
+					isSendingK8SAgentMetrics: false,
+					sentAnyHostMetricsData: true,
+				})}
 			/>,
 		);
 		expect(container.querySelector('.hosts-list-table')).toBeTruthy();

frontend/src/container/InfraMonitoringHosts/utils.tsx

@@ -52,6 +52,17 @@ export interface HostsListTableProps {
 	setPageSize: (pageSize: number) => void;
 }
 
+export interface EmptyOrLoadingViewProps {
+	isError: boolean;
+	errorMessage: string;
+	showHostsEmptyState: boolean;
+	sentAnyHostMetricsData: boolean;
+	isSendingIncorrectK8SAgentMetrics: boolean;
+	showEndTimeBeforeRetentionMessage: boolean;
+	showNoRecordsInSelectedTimeRangeMessage: boolean;
+	showTableLoadingState: boolean;
+}
+
 export const getHostListsQuery = (): HostListPayload => ({
 	filters: {
 		items: [],

frontend/src/container/IngestionSettings/__tests__/MultiIngestionSettings.test.tsx

@@ -36,6 +36,24 @@ jest.mock('react-router-dom', () => {
 	};
 });
 
+// Mock deployments data hook to avoid unrelated network calls in this page
+jest.mock(
+	'hooks/CustomDomain/useGetDeploymentsData',
+	(): Record<string, unknown> => ({
+		useGetDeploymentsData: (): {
+			data: undefined;
+			isLoading: boolean;
+			isFetching: boolean;
+			isError: boolean;
+		} => ({
+			data: undefined,
+			isLoading: false,
+			isFetching: false,
+			isError: false,
+		}),
+	}),
+);
+
 const TEST_CREATED_UPDATED = '2024-01-01T00:00:00Z';
 const TEST_EXPIRES_AT = '2030-01-01T00:00:00Z';
 const TEST_WORKSPACE_ID = 'w1';

frontend/src/container/OnboardingQuestionaire/__tests__/OnboardingQuestionaire.test.tsx

@@ -26,7 +26,7 @@ jest.mock('lib/history', () => ({
 // API Endpoints
 const ORG_PREFERENCES_ENDPOINT = '*/api/v1/org/preferences/list';
 const UPDATE_ORG_PREFERENCE_ENDPOINT = '*/api/v1/org/preferences/name/update';
-const UPDATE_PROFILE_ENDPOINT = '*/api/v2/zeus/profiles';
+const UPDATE_PROFILE_ENDPOINT = '*/api/gateway/v2/profiles/me';
 const EDIT_ORG_ENDPOINT = '*/api/v2/orgs/me';
 const INVITE_USERS_ENDPOINT = '*/api/v1/invite/bulk/create';
 
@@ -277,46 +277,6 @@ describe('OnboardingQuestionaire Component', () => {
 			).toBeInTheDocument();
 		});
 
-		it('fires PUT to /zeus/profiles and advances to step 4 on success', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-			let profilePutCalled = false;
-
-			server.use(
-				rest.put(UPDATE_PROFILE_ENDPOINT, (_, res, ctx) => {
-					profilePutCalled = true;
-					return res(ctx.status(200), ctx.json({ status: 'success', data: {} }));
-				}),
-			);
-
-			render(<OnboardingQuestionaire />);
-
-			// Navigate to step 3
-			await user.click(screen.getByLabelText(/datadog/i));
-			await user.click(screen.getByRole('radio', { name: /yes/i }));
-			await user.click(screen.getByLabelText(/just exploring/i));
-			await user.click(screen.getByRole('button', { name: /next/i }));
-
-			await user.type(
-				await screen.findByPlaceholderText(/e\.g\., googling/i),
-				'Found via Google',
-			);
-			await user.click(screen.getByLabelText(/lowering observability costs/i));
-			await user.click(screen.getByRole('button', { name: /next/i }));
-
-			// Click "I'll do this later" on step 3 — triggers PUT /zeus/profiles
-			await user.click(
-				await screen.findByRole('button', { name: /i'll do this later/i }),
-			);
-
-			await waitFor(() => {
-				expect(profilePutCalled).toBe(true);
-				// Step 3 content is gone — successfully advanced to step 4
-				expect(
-					screen.queryByText(/what does your scale approximately look like/i),
-				).not.toBeInTheDocument();
-			});
-		});
-
 		it('shows do later button', async () => {
 			const user = userEvent.setup({ pointerEventsCheck: 0 });
 			render(<OnboardingQuestionaire />);

frontend/src/container/OnboardingQuestionaire/index.tsx

@@ -1,10 +1,8 @@
 import { useEffect, useState } from 'react';
 import { useMutation, useQuery } from 'react-query';
-import { toast } from '@signozhq/sonner';
 import { NotificationInstance } from 'antd/es/notification/interface';
 import logEvent from 'api/common/logEvent';
-import { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
-import { usePutProfile } from 'api/generated/services/zeus';
+import updateProfileAPI from 'api/onboarding/updateProfile';
 import listOrgPreferences from 'api/v1/org/preferences/list';
 import updateOrgPreferenceAPI from 'api/v1/org/preferences/name/update';
 import { AxiosError } from 'axios';
@@ -123,9 +121,20 @@ function OnboardingQuestionaire(): JSX.Element {
 		optimiseSignozDetails.hostsPerDay === 0 &&
 		optimiseSignozDetails.services === 0;
 
-	const { mutate: updateProfile, isLoading: isUpdatingProfile } = usePutProfile<
-		AxiosError<RenderErrorResponseDTO>
-	>();
+	const { mutate: updateProfile, isLoading: isUpdatingProfile } = useMutation(
+		updateProfileAPI,
+		{
+			onSuccess: () => {
+				setCurrentStep(4);
+			},
+			onError: (error) => {
+				showErrorNotification(notifications, error as AxiosError);
+
+				// Allow user to proceed even if API fails
+				setCurrentStep(4);
+			},
+		},
+	);
 
 	const { mutate: updateOrgPreference } = useMutation(updateOrgPreferenceAPI, {
 		onSuccess: () => {
@@ -144,44 +153,29 @@ function OnboardingQuestionaire(): JSX.Element {
 			nextPageID: 4,
 		});
 
-		updateProfile(
-			{
-				data: {
-					uses_otel: orgDetails?.usesOtel as boolean,
-					has_existing_observability_tool: orgDetails?.usesObservability as boolean,
-					existing_observability_tool:
-						orgDetails?.observabilityTool === 'Others'
-							? (orgDetails?.otherTool as string)
-							: (orgDetails?.observabilityTool as string),
-					where_did_you_discover_signoz: signozDetails?.discoverSignoz as string,
-					timeline_for_migrating_to_signoz: orgDetails?.migrationTimeline as string,
-					reasons_for_interest_in_signoz: signozDetails?.interestInSignoz?.includes(
-						'Others',
-					)
-						? ([
-								...(signozDetails?.interestInSignoz?.filter(
-									(item) => item !== 'Others',
-								) || []),
-								signozDetails?.otherInterestInSignoz,
-						  ] as string[])
-						: (signozDetails?.interestInSignoz as string[]),
-					logs_scale_per_day_in_gb: optimiseSignozDetails?.logsPerDay as number,
-					number_of_hosts: optimiseSignozDetails?.hostsPerDay as number,
-					number_of_services: optimiseSignozDetails?.services as number,
-				},
-			},
-			{
-				onSuccess: () => {
-					setCurrentStep(4);
-				},
-				onError: (error: any) => {
-					toast.error(error?.message || SOMETHING_WENT_WRONG);
-
-					// Allow user to proceed even if API fails
-					setCurrentStep(4);
-				},
-			},
-		);
+		updateProfile({
+			uses_otel: orgDetails?.usesOtel as boolean,
+			has_existing_observability_tool: orgDetails?.usesObservability as boolean,
+			existing_observability_tool:
+				orgDetails?.observabilityTool === 'Others'
+					? (orgDetails?.otherTool as string)
+					: (orgDetails?.observabilityTool as string),
+			where_did_you_discover_signoz: signozDetails?.discoverSignoz as string,
+			timeline_for_migrating_to_signoz: orgDetails?.migrationTimeline as string,
+			reasons_for_interest_in_signoz: signozDetails?.interestInSignoz?.includes(
+				'Others',
+			)
+				? ([
+						...(signozDetails?.interestInSignoz?.filter(
+							(item) => item !== 'Others',
+						) || []),
+						signozDetails?.otherInterestInSignoz,
+				  ] as string[])
+				: (signozDetails?.interestInSignoz as string[]),
+			logs_scale_per_day_in_gb: optimiseSignozDetails?.logsPerDay as number,
+			number_of_hosts: optimiseSignozDetails?.hostsPerDay as number,
+			number_of_services: optimiseSignozDetails?.services as number,
+		});
 	};
 
 	const handleOnboardingComplete = (): void => {

frontend/src/container/SpanDetailsDrawer/__tests__/AttributeActions.userflow.test.tsx

@@ -3,7 +3,6 @@ import { MemoryRouter, Route } from 'react-router-dom';
 import { fireEvent, render, screen, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import ROUTES from 'constants/routes';
-import { SPAN_ATTRIBUTES } from 'container/ApiMonitoring/Explorer/Domains/DomainDetails/constants';
 import { AppProvider } from 'providers/App/App';
 import MockQueryClientProvider from 'providers/test/MockQueryClientProvider';
 import { Span } from 'types/api/trace/getTraceV2';
@@ -109,7 +108,7 @@ const createMockSpan = (): Span => ({
 	statusMessage: '',
 	tagMap: {
 		'http.method': 'GET',
-		[SPAN_ATTRIBUTES.HTTP_URL]: '/api/users?page=1',
+		'http.url': '/api/users?page=1',
 		'http.status_code': '200',
 		'service.name': 'frontend-service',
 		'span.kind': 'server',

frontend/src/container/SpanDetailsDrawer/__tests__/SpanDetailsDrawer.test.tsx

@@ -5,7 +5,6 @@ import getSpanPercentiles from 'api/trace/getSpanPercentiles';
 import getUserPreference from 'api/v1/user/preferences/name/get';
 import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
-import { SPAN_ATTRIBUTES } from 'container/ApiMonitoring/Explorer/Domains/DomainDetails/constants';
 import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
 import { server } from 'mocks-server/server';
 import { QueryBuilderContext } from 'providers/QueryBuilder';
@@ -879,9 +878,7 @@ describe('SpanDetailsDrawer', () => {
 
 			// Verify only matching attributes are shown (use getAllByText for all since they appear in multiple places)
 			expect(screen.getAllByText('http.method').length).toBeGreaterThan(0);
-			expect(screen.getAllByText(SPAN_ATTRIBUTES.HTTP_URL).length).toBeGreaterThan(
-				0,
-			);
+			expect(screen.getAllByText('http.url').length).toBeGreaterThan(0);
 			expect(screen.getAllByText('http.status_code').length).toBeGreaterThan(0);
 		});
 
@@ -1129,7 +1126,7 @@ describe('SpanDetailsDrawer - Search Visibility User Flows', () => {
 
 		// User sees all attributes initially
 		expect(screen.getByText('http.method')).toBeInTheDocument();
-		expect(screen.getByText(SPAN_ATTRIBUTES.HTTP_URL)).toBeInTheDocument();
+		expect(screen.getByText('http.url')).toBeInTheDocument();
 		expect(screen.getByText('http.status_code')).toBeInTheDocument();
 
 		// User types "method" in search
@@ -1139,7 +1136,7 @@ describe('SpanDetailsDrawer - Search Visibility User Flows', () => {
 		// User sees only matching attributes
 		await waitFor(() => {
 			expect(screen.getByText('http.method')).toBeInTheDocument();
-			expect(screen.queryByText(SPAN_ATTRIBUTES.HTTP_URL)).not.toBeInTheDocument();
+			expect(screen.queryByText('http.url')).not.toBeInTheDocument();
 			expect(screen.queryByText('http.status_code')).not.toBeInTheDocument();
 		});
 	});

frontend/src/container/SpanDetailsDrawer/__tests__/mockData.ts

@@ -1,4 +1,3 @@
-import { SPAN_ATTRIBUTES } from 'container/ApiMonitoring/Explorer/Domains/DomainDetails/constants';
 import { ILog } from 'types/api/logs/log';
 import { Span } from 'types/api/trace/getTraceV2';
 
@@ -23,7 +22,7 @@ export const mockSpan: Span = {
 	event: [],
 	tagMap: {
 		'http.method': 'GET',
-		[SPAN_ATTRIBUTES.HTTP_URL]: '/api/test',
+		'http.url': '/api/test',
 		'http.status_code': '200',
 	},
 	hasError: false,

frontend/src/hooks/CustomDomain/useGetDeploymentsData.ts

@@ -0,0 +1,13 @@
+import { useQuery, UseQueryResult } from 'react-query';
+import { getDeploymentsData } from 'api/customDomain/getDeploymentsData';
+import { AxiosError, AxiosResponse } from 'axios';
+import { DeploymentsDataProps } from 'types/api/customDomain/types';
+
+export const useGetDeploymentsData = (
+	isEnabled: boolean,
+): UseQueryResult<AxiosResponse<DeploymentsDataProps>, AxiosError> =>
+	useQuery<AxiosResponse<DeploymentsDataProps>, AxiosError>({
+		queryKey: ['getDeploymentsData'],
+		queryFn: () => getDeploymentsData(),
+		enabled: isEnabled,
+	});

frontend/src/hooks/IngestionKeys/useGetAllIngestionKeys.ts

@@ -0,0 +1,15 @@
+import { useQuery, UseQueryResult } from 'react-query';
+import { getAllIngestionKeys } from 'api/IngestionKeys/getAllIngestionKeys';
+import { AxiosError, AxiosResponse } from 'axios';
+import {
+	AllIngestionKeyProps,
+	GetIngestionKeyProps,
+} from 'types/api/ingestionKeys/types';
+
+export const useGetAllIngestionsKeys = (
+	props: GetIngestionKeyProps,
+): UseQueryResult<AxiosResponse<AllIngestionKeyProps>, AxiosError> =>
+	useQuery<AxiosResponse<AllIngestionKeyProps>, AxiosError>({
+		queryKey: [`IngestionKeys-${props.page}-${props.search}`],
+		queryFn: () => getAllIngestionKeys(props),
+	});

frontend/src/mocks-server/__mockdata__/tracedetail.ts

@@ -1,5 +1,3 @@
-import { SPAN_ATTRIBUTES } from 'container/ApiMonitoring/Explorer/Domains/DomainDetails/constants';
-
 /* eslint-disable sonarjs/no-duplicate-string */
 export const traceDetailResponse = [
 	{
@@ -37,7 +35,7 @@ export const traceDetailResponse = [
 					'component',
 					'host.name',
 					'http.method',
-					SPAN_ATTRIBUTES.HTTP_URL,
+					'http.url',
 					'ip',
 					'http.status_code',
 					'opencensus.exporterversion',
@@ -86,7 +84,7 @@ export const traceDetailResponse = [
 					'signoz.collector.id',
 					'component',
 					'http.method',
-					SPAN_ATTRIBUTES.HTTP_URL,
+					'http.url',
 					'ip',
 				],
 				[
@@ -743,7 +741,7 @@ export const traceDetailResponse = [
 					'component',
 					'http.method',
 					'http.status_code',
-					SPAN_ATTRIBUTES.HTTP_URL,
+					'http.url',
 					'net/http.reused',
 					'net/http.was_idle',
 					'service.name',
@@ -835,7 +833,7 @@ export const traceDetailResponse = [
 					'opencensus.exporterversion',
 					'signoz.collector.id',
 					'host.name',
-					SPAN_ATTRIBUTES.HTTP_URL,
+					'http.url',
 					'net/http.reused',
 					'net/http.was_idle',
 				],
@@ -918,7 +916,7 @@ export const traceDetailResponse = [
 					'net/http.was_idle',
 					'component',
 					'host.name',
-					SPAN_ATTRIBUTES.HTTP_URL,
+					'http.url',
 					'ip',
 					'service.name',
 					'signoz.collector.id',

frontend/src/pages/TracesExplorer/Filter/filterUtils.ts

@@ -2,7 +2,6 @@
 import { Dispatch, SetStateAction, useEffect, useState } from 'react';
 import { getAttributesValues } from 'api/queryBuilder/getAttributesValues';
 import { DATA_TYPE_VS_ATTRIBUTE_VALUES_KEY } from 'constants/queryBuilder';
-import { SPAN_ATTRIBUTES } from 'container/ApiMonitoring/Explorer/Domains/DomainDetails/constants';
 import {
 	BaseAutocompleteData,
 	DataTypes,
@@ -32,7 +31,7 @@ export const AllTraceFilterKeyValue: Record<string, string> = {
 	httpRoute: 'HTTP Route',
 	'http.route': 'HTTP Route',
 	httpUrl: 'HTTP URL',
-	[SPAN_ATTRIBUTES.HTTP_URL]: 'HTTP URL',
+	'http.url': 'HTTP URL',
 	traceID: 'Trace ID',
 	trace_id: 'Trace ID',
 } as const;

frontend/src/types/api/customDomain/types.ts

@@ -0,0 +1,53 @@
+export interface HostsProps {
+	name: string;
+	is_default: boolean;
+}
+
+export interface RegionProps {
+	id: string;
+	name: string;
+	category: string;
+	dns: string;
+	created_at: string;
+	updated_at: string;
+}
+
+export interface ClusterProps {
+	id: string;
+	name: string;
+	cloud_account_id: string;
+	cloud_region: string;
+	address: string;
+	region: RegionProps;
+}
+
+export interface DeploymentData {
+	id: string;
+	name: string;
+	email: string;
+	state: string;
+	tier: string;
+	user: string;
+	password: string;
+	created_at: string;
+	updated_at: string;
+	cluster_id: string;
+	hosts: HostsProps[];
+	cluster: ClusterProps;
+}
+
+export interface DeploymentsDataProps {
+	status: string;
+	data: DeploymentData;
+}
+
+export type PayloadProps = {
+	status: string;
+	data: string;
+};
+
+export interface UpdateCustomDomainProps {
+	data: {
+		name: string;
+	};
+}

frontend/src/types/api/onboarding/types.ts

@@ -0,0 +1,11 @@
+export interface UpdateProfileProps {
+	reasons_for_interest_in_signoz: string[];
+	uses_otel: boolean;
+	has_existing_observability_tool: boolean;
+	existing_observability_tool: string;
+	logs_scale_per_day_in_gb: number;
+	number_of_services: number;
+	number_of_hosts: number;
+	where_did_you_discover_signoz: string;
+	timeline_for_migrating_to_signoz: string;
+}

pkg/query-service/app/clickhouseReader/reader.go

@@ -4308,6 +4308,28 @@ func (r *ClickHouseReader) GetListResultV3(ctx context.Context, query string) ([
 
 }
 
+// GetHostMetricsExistenceAndEarliestTime returns (count, minFirstReportedUnixMilli, error) for the given host metric names
+// from distributed_metadata. When count is 0, minFirstReportedUnixMilli is 0.
+func (r *ClickHouseReader) GetHostMetricsExistenceAndEarliestTime(ctx context.Context, metricNames []string) (uint64, uint64, error) {
+	if len(metricNames) == 0 {
+		return 0, 0, nil
+	}
+
+	query := fmt.Sprintf(
+		`SELECT count(*) AS cnt, min(first_reported_unix_milli) AS min_first_reported
+		FROM %s.%s
+		WHERE metric_name IN @metric_names`,
+		constants.SIGNOZ_METRIC_DBNAME, constants.SIGNOZ_METADATA_TABLENAME)
+
+	var count, minFirstReported uint64
+	err := r.db.QueryRow(ctx, query, clickhouse.Named("metric_names", metricNames)).Scan(&count, &minFirstReported)
+	if err != nil {
+		zap.L().Error("error getting host metrics existence and earliest time", zap.Error(err))
+		return 0, 0, err
+	}
+	return count, minFirstReported, nil
+}
+
 func getPersonalisedError(err error) error {
 	if err == nil {
 		return nil

pkg/query-service/app/inframetrics/common.go

@@ -10,6 +10,7 @@ import (
 )
 
 var dotMetricMap = map[string]string{
+	"system_filesystem_usage":               "system.filesystem.usage",
 	"system_cpu_time":                       "system.cpu.time",
 	"system_memory_usage":                   "system.memory.usage",
 	"system_cpu_load_average_15m":           "system.cpu.load_average.15m",

pkg/query-service/app/inframetrics/hosts.go

@@ -67,10 +67,11 @@ var (
 		GetDotMetrics("os_type"),
 	}
 	metricNamesForHosts = map[string]string{
-		"cpu":    GetDotMetrics("system_cpu_time"),
-		"memory": GetDotMetrics("system_memory_usage"),
-		"load15": GetDotMetrics("system_cpu_load_average_15m"),
-		"wait":   GetDotMetrics("system_cpu_time"),
+		"filesystem": GetDotMetrics("system_filesystem_usage"),
+		"cpu":        GetDotMetrics("system_cpu_time"),
+		"memory":     GetDotMetrics("system_memory_usage"),
+		"load15":     GetDotMetrics("system_cpu_load_average_15m"),
+		"wait":       GetDotMetrics("system_cpu_time"),
 	}
 )
 
@@ -316,24 +317,15 @@ func (h *HostsRepo) getTopHostGroups(ctx context.Context, orgID valuer.UUID, req
 	return topHostGroups, allHostGroups, nil
 }
 
-func (h *HostsRepo) DidSendHostMetricsData(ctx context.Context, req model.HostListRequest) (bool, error) {
-
+// GetHostMetricsExistenceAndEarliestTime returns (count, minFirstReportedUnixMilli, error) for host metrics
+// in distributed_metadata. Uses metricNamesForHosts plus system.filesystem.usage.
+func (h *HostsRepo) GetHostMetricsExistenceAndEarliestTime(ctx context.Context, req model.HostListRequest) (uint64, uint64, error) {
 	names := []string{}
 	for _, metricName := range metricNamesForHosts {
 		names = append(names, metricName)
 	}
 
-	namesStr := "'" + strings.Join(names, "','") + "'"
-
-	query := fmt.Sprintf("SELECT count() FROM %s.%s WHERE metric_name IN (%s)",
-		constants.SIGNOZ_METRIC_DBNAME, constants.SIGNOZ_TIMESERIES_v4_1DAY_TABLENAME, namesStr)
-
-	count, err := h.reader.GetCountOfThings(ctx, query)
-	if err != nil {
-		return false, err
-	}
-
-	return count > 0, nil
+	return h.reader.GetHostMetricsExistenceAndEarliestTime(ctx, names)
 }
 
 func (h *HostsRepo) IsSendingK8SAgentMetrics(ctx context.Context, req model.HostListRequest) ([]string, []string, error) {
@@ -412,8 +404,25 @@ func (h *HostsRepo) GetHostList(ctx context.Context, orgID valuer.UUID, req mode
 		resp.ClusterNames = clusterNames
 		resp.NodeNames = nodeNames
 	}
-	if sentAnyHostMetricsData, err := h.DidSendHostMetricsData(ctx, req); err == nil {
-		resp.SentAnyHostMetricsData = sentAnyHostMetricsData
+
+	// 1. Check if any host metrics exist and get earliest retention time
+	// if no hosts metrics exist, that means we should show the onboarding guide on UI, and return early.
+	// 2. If host metrics exist, but req.End is earlier than the earliest time of host metrics as read from
+	// metadata table, then we should convey the same to the user and return early
+	if count, minFirstReportedUnixMilli, err := h.GetHostMetricsExistenceAndEarliestTime(ctx, req); err == nil {
+		if count == 0 {
+			resp.SentAnyHostMetricsData = false
+			resp.Records = []model.HostListRecord{}
+			resp.Total = 0
+			return resp, nil
+		}
+		resp.SentAnyHostMetricsData = true
+		if req.End < int64(minFirstReportedUnixMilli) {
+			resp.EndTimeBeforeRetention = true
+			resp.Records = []model.HostListRecord{}
+			resp.Total = 0
+			return resp, nil
+		}
 	}
 
 	step := int64(math.Max(float64(common.MinAllowedStepInterval(req.Start, req.End)), 60))

pkg/query-service/constants/constants.go

@@ -125,6 +125,8 @@ const (
 	SIGNOZ_TIMESERIES_v4_6HRS_TABLENAME        = "distributed_time_series_v4_6hrs"
 	SIGNOZ_ATTRIBUTES_METADATA_TABLENAME       = "distributed_attributes_metadata"
 	SIGNOZ_ATTRIBUTES_METADATA_LOCAL_TABLENAME = "attributes_metadata"
+	SIGNOZ_METADATA_TABLENAME                  = "distributed_metadata"
+	SIGNOZ_METADATA_LOCAL_TABLENAME            = "metadata"
 )
 
 // alert related constants

pkg/query-service/interfaces/interface.go

@@ -100,6 +100,8 @@ type Reader interface {
 
 	GetCountOfThings(ctx context.Context, query string) (uint64, error)
 
+	GetHostMetricsExistenceAndEarliestTime(ctx context.Context, metricNames []string) (uint64, uint64, error)
+
 	//trace
 	GetTraceFields(ctx context.Context) (*model.GetFieldsResponse, *model.ApiError)
 	UpdateTraceField(ctx context.Context, field *model.UpdateField) *model.ApiError

pkg/query-service/model/infra.go

@@ -44,6 +44,7 @@ type HostListResponse struct {
 	IsSendingK8SAgentMetrics bool             `json:"isSendingK8SAgentMetrics"`
 	ClusterNames             []string         `json:"clusterNames"`
 	NodeNames                []string         `json:"nodeNames"`
+	EndTimeBeforeRetention   bool             `json:"endTimeBeforeRetention"`
 }
 
 func (r *HostListResponse) SortBy(orderBy *v3.OrderBy) {