fix: switch to new derived attributes for ip filtering

In domain listing api for external api monitoring,
we have option to filter out the IP address but
it only handles timeseries and raw type data while
domain list handler returns scalar data.

frontend/src/components/LogDetail/LogDetails.styles.scss

@@ -42,7 +42,6 @@
 		display: flex;
 		flex-direction: column;
 		padding: 16px;
-		padding-bottom: 0;
 	}
 
 	.title {
@@ -191,7 +190,7 @@
 		padding: 0px;
 	}
 	.log-detail-drawer__footer-hint {
-		position: sticky;
+		position: absolute;
 		bottom: 0;
 		left: 0;
 		right: 0;
@@ -367,7 +366,7 @@
 	}
 
 	.log-detail-drawer__footer-hint {
-		position: sticky;
+		position: absolute;
 		bottom: 0;
 		left: 0;
 		right: 0;

frontend/src/container/DashboardContainer/DashboardVariablesSelection/DashboardVariableSelection.tsx

@@ -34,9 +34,6 @@ function DashboardVariableSelection(): JSX.Element | null {
 	const sortedVariablesArray = useDashboardVariablesSelector(
 		(state) => state.sortedVariablesArray,
 	);
-	const dynamicVariableOrder = useDashboardVariablesSelector(
-		(state) => state.dynamicVariableOrder,
-	);
 	const dependencyData = useDashboardVariablesSelector(
 		(state) => state.dependencyData,
 	);
@@ -55,11 +52,10 @@ function DashboardVariableSelection(): JSX.Element | null {
 	}, [getUrlVariables, updateUrlVariable, dashboardVariables]);
 
 	// Memoize the order key to avoid unnecessary triggers
-	const variableOrderKey = useMemo(() => {
-		const queryVariableOrderKey = dependencyData?.order?.join(',') ?? '';
-		const dynamicVariableOrderKey = dynamicVariableOrder?.join(',') ?? '';
-		return `${queryVariableOrderKey}|${dynamicVariableOrderKey}`;
-	}, [dependencyData?.order, dynamicVariableOrder]);
+	const dependencyOrderKey = useMemo(
+		() => dependencyData?.order?.join(',') ?? '',
+		[dependencyData?.order],
+	);
 
 	// Initialize fetch store then start a new fetch cycle.
 	// Runs on dependency order changes, and time range changes.
@@ -70,7 +66,7 @@ function DashboardVariableSelection(): JSX.Element | null {
 		initializeVariableFetchStore(allVariableNames);
 		enqueueFetchOfAllVariables();
 		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [variableOrderKey, minTime, maxTime]);
+	}, [dependencyOrderKey, minTime, maxTime]);
 
 	// Performance optimization: For dynamic variables with allSelected=true, we don't store
 	// individual values in localStorage since we can always derive them from available options.

frontend/src/container/DashboardContainer/DashboardVariablesSelection/__test__/DashboardVariableSelection.test.tsx

@@ -1,203 +0,0 @@
-/* eslint-disable sonarjs/no-duplicate-string */
-import { act, render } from '@testing-library/react';
-import {
-	dashboardVariablesStore,
-	setDashboardVariablesStore,
-	updateDashboardVariablesStore,
-} from 'providers/Dashboard/store/dashboardVariables/dashboardVariablesStore';
-import {
-	IDashboardVariables,
-	IDashboardVariablesStoreState,
-} from 'providers/Dashboard/store/dashboardVariables/dashboardVariablesStoreTypes';
-import {
-	enqueueFetchOfAllVariables,
-	initializeVariableFetchStore,
-} from 'providers/Dashboard/store/variableFetchStore';
-import { IDashboardVariable } from 'types/api/dashboard/getAll';
-
-import DashboardVariableSelection from '../DashboardVariableSelection';
-
-// Mock providers/Dashboard/Dashboard
-const mockSetSelectedDashboard = jest.fn();
-const mockUpdateLocalStorageDashboardVariables = jest.fn();
-jest.mock('providers/Dashboard/Dashboard', () => ({
-	useDashboard: (): Record<string, unknown> => ({
-		setSelectedDashboard: mockSetSelectedDashboard,
-		updateLocalStorageDashboardVariables: mockUpdateLocalStorageDashboardVariables,
-	}),
-}));
-
-// Mock hooks/dashboard/useVariablesFromUrl
-const mockUpdateUrlVariable = jest.fn();
-const mockGetUrlVariables = jest.fn().mockReturnValue({});
-jest.mock('hooks/dashboard/useVariablesFromUrl', () => ({
-	__esModule: true,
-	default: (): Record<string, unknown> => ({
-		updateUrlVariable: mockUpdateUrlVariable,
-		getUrlVariables: mockGetUrlVariables,
-	}),
-}));
-
-// Mock variableFetchStore functions
-jest.mock('providers/Dashboard/store/variableFetchStore', () => ({
-	initializeVariableFetchStore: jest.fn(),
-	enqueueFetchOfAllVariables: jest.fn(),
-	enqueueDescendantsOfVariable: jest.fn(),
-}));
-
-// Mock initializeDefaultVariables
-jest.mock('providers/Dashboard/initializeDefaultVariables', () => ({
-	initializeDefaultVariables: jest.fn(),
-}));
-
-// Mock react-redux useSelector for globalTime
-jest.mock('react-redux', () => ({
-	...jest.requireActual('react-redux'),
-	useSelector: jest.fn().mockReturnValue({ minTime: 1000, maxTime: 2000 }),
-}));
-
-// Mock VariableItem to avoid rendering complexity
-jest.mock('../VariableItem', () => ({
-	__esModule: true,
-	default: (): JSX.Element => <div data-testid="variable-item" />,
-}));
-
-function createVariable(
-	overrides: Partial<IDashboardVariable> = {},
-): IDashboardVariable {
-	return {
-		id: 'test-id',
-		name: 'test-var',
-		description: '',
-		type: 'QUERY',
-		sort: 'DISABLED',
-		showALLOption: false,
-		multiSelect: false,
-		order: 0,
-		...overrides,
-	};
-}
-
-function resetStore(): void {
-	dashboardVariablesStore.set(() => ({
-		dashboardId: '',
-		variables: {},
-		sortedVariablesArray: [],
-		dependencyData: null,
-		variableTypes: {},
-		dynamicVariableOrder: [],
-	}));
-}
-
-describe('DashboardVariableSelection', () => {
-	beforeEach(() => {
-		resetStore();
-		jest.clearAllMocks();
-	});
-
-	it('should call initializeVariableFetchStore and enqueueFetchOfAllVariables on mount', () => {
-		const variables: IDashboardVariables = {
-			env: createVariable({ name: 'env', type: 'QUERY', order: 0 }),
-		};
-
-		setDashboardVariablesStore({ dashboardId: 'dash-1', variables });
-
-		render(<DashboardVariableSelection />);
-
-		expect(initializeVariableFetchStore).toHaveBeenCalledWith(['env']);
-		expect(enqueueFetchOfAllVariables).toHaveBeenCalled();
-	});
-
-	it('should re-trigger fetch cycle when dynamicVariableOrder changes', () => {
-		const variables: IDashboardVariables = {
-			env: createVariable({ name: 'env', type: 'QUERY', order: 0 }),
-		};
-
-		setDashboardVariablesStore({ dashboardId: 'dash-1', variables });
-
-		render(<DashboardVariableSelection />);
-
-		// Clear mocks after initial render
-		(initializeVariableFetchStore as jest.Mock).mockClear();
-		(enqueueFetchOfAllVariables as jest.Mock).mockClear();
-
-		// Add a DYNAMIC variable which changes dynamicVariableOrder
-		act(() => {
-			updateDashboardVariablesStore({
-				dashboardId: 'dash-1',
-				variables: {
-					env: createVariable({ name: 'env', type: 'QUERY', order: 0 }),
-					dyn1: createVariable({ name: 'dyn1', type: 'DYNAMIC', order: 1 }),
-				},
-			});
-		});
-
-		expect(initializeVariableFetchStore).toHaveBeenCalledWith(
-			expect.arrayContaining(['env', 'dyn1']),
-		);
-		expect(enqueueFetchOfAllVariables).toHaveBeenCalled();
-	});
-
-	it('should re-trigger fetch cycle when a dynamic variable is removed', () => {
-		const variables: IDashboardVariables = {
-			env: createVariable({ name: 'env', type: 'QUERY', order: 0 }),
-			dyn1: createVariable({ name: 'dyn1', type: 'DYNAMIC', order: 1 }),
-			dyn2: createVariable({ name: 'dyn2', type: 'DYNAMIC', order: 2 }),
-		};
-
-		setDashboardVariablesStore({ dashboardId: 'dash-1', variables });
-
-		render(<DashboardVariableSelection />);
-
-		(initializeVariableFetchStore as jest.Mock).mockClear();
-		(enqueueFetchOfAllVariables as jest.Mock).mockClear();
-
-		// Remove dyn2, changing dynamicVariableOrder from ['dyn1','dyn2'] to ['dyn1']
-		act(() => {
-			updateDashboardVariablesStore({
-				dashboardId: 'dash-1',
-				variables: {
-					env: createVariable({ name: 'env', type: 'QUERY', order: 0 }),
-					dyn1: createVariable({ name: 'dyn1', type: 'DYNAMIC', order: 1 }),
-				},
-			});
-		});
-
-		expect(initializeVariableFetchStore).toHaveBeenCalledWith(['env', 'dyn1']);
-		expect(enqueueFetchOfAllVariables).toHaveBeenCalled();
-	});
-
-	it('should NOT re-trigger fetch cycle when dynamicVariableOrder stays the same', () => {
-		const variables: IDashboardVariables = {
-			env: createVariable({ name: 'env', type: 'QUERY', order: 0 }),
-			dyn1: createVariable({ name: 'dyn1', type: 'DYNAMIC', order: 1 }),
-		};
-
-		setDashboardVariablesStore({ dashboardId: 'dash-1', variables });
-
-		render(<DashboardVariableSelection />);
-
-		(initializeVariableFetchStore as jest.Mock).mockClear();
-		(enqueueFetchOfAllVariables as jest.Mock).mockClear();
-
-		// Update a non-dynamic variable's selectedValue — dynamicVariableOrder unchanged
-		act(() => {
-			const snapshot = dashboardVariablesStore.getSnapshot();
-			dashboardVariablesStore.set(
-				(): IDashboardVariablesStoreState => ({
-					...snapshot,
-					variables: {
-						...snapshot.variables,
-						env: {
-							...snapshot.variables.env,
-							selectedValue: 'production',
-						},
-					},
-				}),
-			);
-		});
-
-		expect(initializeVariableFetchStore).not.toHaveBeenCalled();
-		expect(enqueueFetchOfAllVariables).not.toHaveBeenCalled();
-	});
-});

pkg/modules/thirdpartyapi/translator.go

@@ -120,6 +120,8 @@ func FilterResponse(results []*qbtypes.QueryRangeResponse) []*qbtypes.QueryRange
 					}
 				}
 				resultData.Rows = filteredRows
+			case *qbtypes.ScalarData:
+				resultData.Data = filterScalarDataIPs(resultData.Columns, resultData.Data)
 			}
 
 			filteredData = append(filteredData, result)
@@ -145,6 +147,39 @@ func shouldIncludeSeries(series *qbtypes.TimeSeries) bool {
 	return true
 }
 
+func filterScalarDataIPs(columns []*qbtypes.ColumnDescriptor, data [][]any) [][]any {
+	// Find column indices for server address fields
+	serverColIndices := make([]int, 0)
+	for i, col := range columns {
+		if col.Name == derivedKeyHTTPHost {
+			serverColIndices = append(serverColIndices, i)
+		}
+	}
+
+	if len(serverColIndices) == 0 {
+		return data
+	}
+
+	filtered := make([][]any, 0, len(data))
+	for _, row := range data {
+		includeRow := true
+		for _, colIdx := range serverColIndices {
+			if colIdx < len(row) {
+				if strVal, ok := row[colIdx].(string); ok {
+					if net.ParseIP(strVal) != nil {
+						includeRow = false
+						break
+					}
+				}
+			}
+		}
+		if includeRow {
+			filtered = append(filtered, row)
+		}
+	}
+	return filtered
+}
+
 func shouldIncludeRow(row *qbtypes.RawRow) bool {
 	if row.Data != nil {
 		if domainVal, ok := row.Data[derivedKeyHTTPHost]; ok {

pkg/modules/thirdpartyapi/translator_test.go

@@ -117,6 +117,59 @@ func TestFilterResponse(t *testing.T) {
 				},
 			},
 		},
+		{
+			name: "should filter out IP addresses from scalar data",
+			input: []*qbtypes.QueryRangeResponse{
+				{
+					Data: qbtypes.QueryData{
+						Results: []any{
+							&qbtypes.ScalarData{
+								QueryName: "endpoints",
+								Columns: []*qbtypes.ColumnDescriptor{
+									{
+										TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: derivedKeyHTTPHost},
+										Type:              qbtypes.ColumnTypeGroup,
+									},
+									{
+										TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: "endpoints"},
+										Type:              qbtypes.ColumnTypeAggregation,
+									},
+								},
+								Data: [][]any{
+									{"192.168.1.1", 10},
+									{"example.com", 20},
+									{"10.0.0.1", 5},
+								},
+							},
+						},
+					},
+				},
+			},
+			expected: []*qbtypes.QueryRangeResponse{
+				{
+					Data: qbtypes.QueryData{
+						Results: []any{
+							&qbtypes.ScalarData{
+								QueryName: "endpoints",
+								Columns: []*qbtypes.ColumnDescriptor{
+									{
+										TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: derivedKeyHTTPHost},
+										Type:              qbtypes.ColumnTypeGroup,
+									},
+									{
+										TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: "endpoints"},
+										Type:              qbtypes.ColumnTypeAggregation,
+									},
+								},
+								Data: [][]any{
+									{"example.com", 20},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
 	}
 
 	for _, tt := range tests {