Compare commits

..

6 Commits

Author SHA1 Message Date
swapnil-signoz
7c3e2c04e6 test(fileauditor): drop the login and no-license absence checks 2026-11-16 23:23:50 +05:30
swapnil-signoz
734839323c test(fileauditor): inline otlp attribute parsing 2026-11-16 19:44:10 +05:30
swapnil-signoz
346e6cee67 test(fileauditor): cover the audit file write path end to end 2026-11-16 18:30:11 +05:30
hardik-signoz
ce78251920 fix(onboarding): skip onboarding flow for admin@signoz.cloud (#13600)
#### Description

- Stop redirecting `admin@signoz.cloud` to `/onboarding`. The first-user
check excluded that email from the user count but not from the redirect,
so support was locked out of every page on a new deployment until the
customer finished the questionnaire.
- Move the email to a `SIGNOZ_ADMIN_EMAIL` constant, shared by the user
filter and the redirect check.

#### Issues closed by this PR

Closes SigNoz/keystone-pod#217
2026-11-16 09:33:49 +00:00
Ashwin Bhatkal
879b6e4e69 ci(e2e): start e2e on the safe-to-e2e label and run it in the merge queue (#13595)
#### Description

- Adding the `safe-to-e2e` label now starts e2e right away. Before,
`e2eci` ignored label events, so the label only took effect on the next
push or reopen.
- Other labels get their own concurrency group and report as
`ignored-label`, so they never cancel a running e2e or hide its `e2e`
result. They still add a short run of skipped jobs to the checks list.
- The merge queue now runs the full test suite and reports a real `e2e`
result, instead of passing without running anything. Full runs take 17
to 27 minutes, inside the 60-minute queue timeout.
- `fmtlint` is skipped in the merge queue. It only checks `tests/e2e/`,
which each PR's own run already covers.

#### Issues closed by this PR

Closes https://github.com/SigNoz/pulse-pod/issues/736
2026-11-16 08:25:19 +00:00
Aditya Singh
f7e78384ed feat(query-builder): move QueryBuilderSearchV2 off the v3 autocomplete APIs (#13207)
#### Description
- The funnel step filters fetched keys and values from the v3
autocomplete APIs. The backend plans to remove those APIs.
- `QueryBuilderSearchV2` now fetches keys and values from the v5 fields
APIs. The pills and the saved filter shape stay the same, so saved
funnels and pipelines load as before.
- The funnel step Service and Span name dropdowns fetch values from v5
too, scoped to the `resource` and `span` contexts. They share a hook
with the Celery filters, so those move to v5 as well.
- Celery "Worker Online" counts workers from a v5 `query_range` over the
selected time range. It used to count the worker dropdown options, which
had no time range and a cap of 50.
- Pills carry the v5 context as the key type. The pipelines filter
converts it back to the legacy type when the filter changes (`attribute`
→ `tag`, log fields → top-level), so the filter preview, the save and
the stored pipelines match main.
- Span and log fields are marked as columns, so a funnel `EXISTS` on a
field like `name` reads the column.

#### Issues closed by this PR

Closes https://github.com/SigNoz/events-pod/issues/146
Closes https://github.com/SigNoz/events-pod/issues/145

#### Screen recordings
Funnels, Exceptions and pipelines on v5.


https://github.com/user-attachments/assets/217a0a85-984b-4f94-bf9e-a5f21696c3a6


https://github.com/user-attachments/assets/19ba4648-7466-447e-9cf2-e50700022cf9


https://github.com/user-attachments/assets/6dd6e984-d2e6-4a03-b639-a82181618d40

#### Additional Information

- Part of https://github.com/SigNoz/events-pod/issues/156. The same
changes move these filters off v3:
- the exceptions filter, https://github.com/SigNoz/events-pod/issues/145
  - the pipelines filter, https://github.com/SigNoz/events-pod/issues/25
- the Celery dropdowns, https://github.com/SigNoz/events-pod/issues/157
- UI change: the key dropdown badge shows the v5 context, `attribute`
instead of `tag` and `span` for span fields. Neither has a badge colour.
Visible on the funnel step Where filter, the exceptions filter and the
pipelines filter.
- The pipelines filter no longer shows example queries. The v5 fields
API has no equivalent.
- These filters stay on `QueryBuilderSearchV2` with v5 lookups. The move
to `QuerySearch` is left to the page revamps.
- Stories: the Funnels, Celery and Exceptions page stories serve the v5
fields APIs, and the Celery story serves the Worker Online query.
- another PR will be raised to move query range to v5 for logs pipeline
2026-11-16 07:59:24 +00:00
55 changed files with 1162 additions and 772 deletions

View File

@@ -2,44 +2,50 @@ name: e2eci
on:
pull_request:
types:
- opened
- synchronize
- reopened
- labeled
merge_group:
types:
- checks_requested
# Labels other than safe-to-e2e get a group of their own, so they never cancel a running e2e.
concurrency:
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}${{ github.event.action == 'labeled' && github.event.label.name != 'safe-to-e2e' && format('-{0}', github.run_id) || '' }}
cancel-in-progress: true
jobs:
changes:
if: github.event.action != 'labeled' || github.event.label.name == 'safe-to-e2e'
runs-on: ubuntu-latest
outputs:
e2e: ${{ steps.changes.outputs.e2e }}
steps:
- name: merge-queue-pass
if: github.event_name == 'merge_group'
run: echo "::notice::Merge queue run. E2E already gated the PR, so the required e2e check auto-passes."
- name: changes
id: changes
if: github.event_name == 'pull_request'
env:
GH_TOKEN: ${{ github.token }}
PR_NUMBER: ${{ github.event.pull_request.number }}
FORCE: ${{ contains(github.event.pull_request.labels.*.name, 'safe-to-e2e') }}
FORCE: ${{ github.event_name == 'merge_group' || contains(github.event.pull_request.labels.*.name, 'safe-to-e2e') }}
run: |
if [ "$FORCE" = "true" ]; then
echo "e2e=true" >> "$GITHUB_OUTPUT"
exit 0
fi
CHANGED_FILES=$(gh api "repos/$GITHUB_REPOSITORY/pulls/$PR_NUMBER/files" --paginate --jq '.[].filename | select((startswith("tests/integration/") or startswith("frontend/src/api/generated/")) | not)')
PATTERN='^(frontend/|tests/|\.github/workflows/e2eci\.yaml$|cmd/enterprise/Dockerfile\.with-web\.integration$)'
if [ "$FORCE" = "true" ]; then
echo "e2e=true" >> "$GITHUB_OUTPUT"
elif printf '%s\n' "$CHANGED_FILES" | grep -qE "$PATTERN"; then
if printf '%s\n' "$CHANGED_FILES" | grep -qE "$PATTERN"; then
echo "e2e=true" >> "$GITHUB_OUTPUT"
else
echo "e2e=false" >> "$GITHUB_OUTPUT"
fi
fmtlint:
needs: changes
if: needs.changes.outputs.e2e == 'true'
if: github.event_name != 'merge_group' && needs.changes.outputs.e2e == 'true'
runs-on: ubuntu-latest
steps:
- name: checkout
@@ -180,6 +186,8 @@ jobs:
retention-days: 5
# Required status check. Fails when e2e was needed but did not pass.
e2e:
# Runs for other labels must not report as e2e, or their pass would hide the real result.
name: ${{ github.event.action == 'labeled' && github.event.label.name != 'safe-to-e2e' && 'ignored-label' || 'e2e' }}
if: always()
needs: [changes, fmtlint, test]
runs-on: ubuntu-latest

View File

@@ -45,6 +45,7 @@ jobs:
- callbackauthn
- cloudintegrations
- dashboard
- fileauditor
- ingestionkeys
- inframonitoring
- llmpricingrules

View File

@@ -28226,62 +28226,6 @@ paths:
tags:
- rules
x-signoz-stability: alpha
/api/v2/rules/{id}/disable:
post:
deprecated: false
description: This endpoint disables an alert rule by ID without validating its
stored definition, so a rule that no longer passes validation can still be
stopped. Enabling goes through the patch endpoint, which validates the whole
rule.
operationId: DisableRuleByID
parameters:
- in: path
name: id
required: true
schema:
type: string
responses:
"204":
description: No Content
"400":
content:
application/json:
schema:
$ref: '#/components/schemas/RenderErrorResponse'
description: Bad Request
"401":
content:
application/json:
schema:
$ref: '#/components/schemas/RenderErrorResponse'
description: Unauthorized
"403":
content:
application/json:
schema:
$ref: '#/components/schemas/RenderErrorResponse'
description: Forbidden
"404":
content:
application/json:
schema:
$ref: '#/components/schemas/RenderErrorResponse'
description: Not Found
"500":
content:
application/json:
schema:
$ref: '#/components/schemas/RenderErrorResponse'
description: Internal Server Error
security:
- api_key:
- rule:update
- tokenizer:
- rule:update
summary: Disable alert rule
tags:
- rules
x-signoz-stability: alpha
/api/v2/rules/{id}/history/filter_keys:
get:
deprecated: false

View File

@@ -13,6 +13,7 @@ import { useAppContext } from 'providers/App/App';
import { LicensePlatform, LicenseState } from 'types/api/licensesV3/getActive';
import { OrgPreference } from 'types/api/preferences/preference';
import { USER_ROLES } from 'types/roles';
import { isSignozAdminEmail } from 'utils/app';
import {
routePermission,
routeWithInitialAuthZSupport,
@@ -75,7 +76,7 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
const users = usersData?.data || [];
const remainingUsers = (Array.isArray(users) ? users : []).filter(
(user) => user.email !== 'admin@signoz.cloud',
(u) => !isSignozAdminEmail(u.email),
);
return remainingUsers.length === 1;
@@ -203,6 +204,7 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
const isFirstUser = checkFirstTimeUser();
if (
isFirstUser &&
!isSignozAdminEmail(user.email) &&
!isOnboardingComplete &&
!ROUTES_NOT_TO_BE_OVERRIDEN.includes(pathname) &&
pathname !== ROUTES.ONBOARDING

View File

@@ -2,6 +2,7 @@ import { ReactElement } from 'react';
import { QueryClient, QueryClientProvider } from 'react-query';
import { MemoryRouter, Route, Switch, useLocation } from 'react-router-dom';
import { act, render, screen, waitFor } from '@testing-library/react';
import { SIGNOZ_ADMIN_EMAIL } from 'constants/app';
import { LOCALSTORAGE } from 'constants/localStorage';
import { ORG_PREFERENCES } from 'constants/orgPreferences';
import ROUTES from 'constants/routes';
@@ -1089,6 +1090,33 @@ describe('PrivateRoute', () => {
await assertRedirectsTo(ROUTES.ONBOARDING);
});
it('should not redirect the signoz admin to onboarding while the first user has not completed it', async () => {
mockUsersData = [
{ email: 'test@example.com' },
{ email: SIGNOZ_ADMIN_EMAIL },
];
renderPrivateRoute({
initialRoute: ROUTES.HOME,
appContext: {
isLoggedIn: true,
isFetchingOrgPreferences: false,
orgPreferences: createMockOrgPreferences(false),
user: createMockUser({
role: USER_ROLES.ADMIN as ROLES,
email: SIGNOZ_ADMIN_EMAIL,
}),
},
isCloudUser: true,
});
await act(async () => {
await Promise.resolve();
});
assertStaysOnRoute(ROUTES.HOME);
});
it('should not redirect to onboarding when org preferences are still fetching', () => {
renderPrivateRoute({
initialRoute: ROUTES.HOME,

View File

@@ -24,7 +24,6 @@ import type {
CreateRuleView201,
DeleteRuleByIDPathParameters,
DeleteRuleViewPathParameters,
DisableRuleByIDPathParameters,
GetRuleByID200,
GetRuleByIDPathParameters,
GetRuleHistoryFilterKeys200,
@@ -965,85 +964,6 @@ export const useCloneRuleByID = <
> => {
return useMutation(getCloneRuleByIDMutationOptions(options));
};
/**
* This endpoint disables an alert rule by ID without validating its stored definition, so a rule that no longer passes validation can still be stopped. Enabling goes through the patch endpoint, which validates the whole rule.
* @summary Disable alert rule
*/
export const disableRuleByID = (
{ id }: DisableRuleByIDPathParameters,
signal?: AbortSignal,
) => {
return GeneratedAPIInstance<void>({
url: `/api/v2/rules/${id}/disable`,
method: 'POST',
signal,
});
};
export const getDisableRuleByIDMutationOptions = <
TError = ErrorType<RenderErrorResponseDTO>,
TContext = unknown,
>(options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof disableRuleByID>>,
TError,
{ pathParams: DisableRuleByIDPathParameters },
TContext
>;
}): UseMutationOptions<
Awaited<ReturnType<typeof disableRuleByID>>,
TError,
{ pathParams: DisableRuleByIDPathParameters },
TContext
> => {
const mutationKey = ['disableRuleByID'];
const { mutation: mutationOptions } = options
? options.mutation &&
'mutationKey' in options.mutation &&
options.mutation.mutationKey
? options
: { ...options, mutation: { ...options.mutation, mutationKey } }
: { mutation: { mutationKey } };
const mutationFn: MutationFunction<
Awaited<ReturnType<typeof disableRuleByID>>,
{ pathParams: DisableRuleByIDPathParameters }
> = (props) => {
const { pathParams } = props ?? {};
return disableRuleByID(pathParams);
};
return { mutationFn, ...mutationOptions };
};
export type DisableRuleByIDMutationResult = NonNullable<
Awaited<ReturnType<typeof disableRuleByID>>
>;
export type DisableRuleByIDMutationError = ErrorType<RenderErrorResponseDTO>;
/**
* @summary Disable alert rule
*/
export const useDisableRuleByID = <
TError = ErrorType<RenderErrorResponseDTO>,
TContext = unknown,
>(options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof disableRuleByID>>,
TError,
{ pathParams: DisableRuleByIDPathParameters },
TContext
>;
}): UseMutationResult<
Awaited<ReturnType<typeof disableRuleByID>>,
TError,
{ pathParams: DisableRuleByIDPathParameters },
TContext
> => {
return useMutation(getDisableRuleByIDMutationOptions(options));
};
/**
* Returns distinct label keys from rule history entries for the selected range.
* @summary Get rule history filter keys

View File

@@ -16750,9 +16750,6 @@ export type CloneRuleByID201 = {
status: string;
};
export type DisableRuleByIDPathParameters = {
id: string;
};
export type GetRuleHistoryFilterKeysPathParameters = {
id: string;
};

View File

@@ -1,5 +1,6 @@
import { useCallback, useMemo, useState } from 'react';
import { Row, Select, Spin } from 'antd';
import { TelemetrytypesFieldContextDTO } from 'api/generated/services/sigNoz.schemas';
import { navigate } from 'lib/router/navigation';
import { useAppLocation } from 'lib/router/useAppLocation';
import {
@@ -17,6 +18,7 @@ export interface SelectOptionConfig {
placeholder: string;
queryParam: QueryParams;
filterType: string | string[];
fieldContext?: TelemetrytypesFieldContextDTO;
shouldSetQueryParams?: boolean;
onChange?: (value: string | string[]) => void;
values?: string | string[];
@@ -27,13 +29,16 @@ export function FilterSelect({
placeholder,
queryParam,
filterType,
fieldContext,
values,
shouldSetQueryParams,
onChange,
isMultiple,
}: SelectOptionConfig): JSX.Element {
const { handleSearch, isFetching, options } =
useCeleryFilterOptions(filterType);
const { handleSearch, isFetching, options } = useCeleryFilterOptions(
filterType,
fieldContext,
);
const urlQuery = useUrlQuery();
const location = useAppLocation();
@@ -118,6 +123,7 @@ export function FilterSelect({
}
FilterSelect.defaultProps = {
fieldContext: undefined,
shouldSetQueryParams: true,
onChange: (): void => {},
values: [],
@@ -129,12 +135,14 @@ function CeleryOverviewConfigOptions(): JSX.Element {
{
placeholder: 'Service Name',
queryParam: QueryParams.service,
filterType: 'serviceName',
filterType: 'service.name',
fieldContext: TelemetrytypesFieldContextDTO.resource,
},
{
placeholder: 'Span Name',
queryParam: QueryParams.spanName,
filterType: 'name',
fieldContext: TelemetrytypesFieldContextDTO.span,
},
{
placeholder: 'Msg System',
@@ -162,6 +170,7 @@ function CeleryOverviewConfigOptions(): JSX.Element {
placeholder={config.placeholder}
queryParam={config.queryParam}
filterType={config.filterType}
fieldContext={config.fieldContext}
/>
))}
</Row>

View File

@@ -0,0 +1,37 @@
import type { GetFieldsValues200 } from 'api/generated/services/sigNoz.schemas';
import { rest, server } from 'mocks-server/server';
import { render, waitFor } from 'tests/test-utils';
import CeleryOverviewConfigOptions from '../CeleryOverviewConfigOptions';
const emptyValues: GetFieldsValues200 = {
status: 'success',
data: { complete: true, values: { stringValues: [] } },
};
describe('CeleryOverviewConfigOptions', () => {
it('scopes the service and span name lookups to their field context', async () => {
const contextByKey = new Map<string, string | null>();
server.use(
rest.get('*/api/v1/fields/values', (req, res, ctx) => {
contextByKey.set(
req.url.searchParams.get('name') ?? '',
req.url.searchParams.get('fieldContext'),
);
return res(ctx.status(200), ctx.json(emptyValues));
}),
);
render(<CeleryOverviewConfigOptions />);
await waitFor(() => expect(contextByKey.size).toBe(6));
expect(Object.fromEntries(contextByKey)).toStrictEqual({
'service.name': 'resource',
name: 'span',
'messaging.system': null,
'messaging.destination.name': null,
'messaging.destination': null,
kind_string: null,
});
});
});

View File

@@ -1,23 +1,21 @@
import { useQuery } from 'react-query';
// eslint-disable-next-line no-restricted-imports
import { useSelector } from 'react-redux';
import type { DefaultOptionType } from 'antd/es/select';
import { getAttributesValues } from 'api/queryBuilder/getAttributesValues';
import { DATA_TYPE_VS_ATTRIBUTE_VALUES_KEY } from 'constants/queryBuilder';
import type { TelemetrytypesFieldContextDTO } from 'api/generated/services/sigNoz.schemas';
import { getFieldValueSuggestions } from 'api/querySuggestions/getFieldValueSuggestions';
import { FIELD_API_CACHE_TIME } from 'constants/queryCacheTime';
import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
import { AppState } from 'store/reducers';
import { toFieldValues } from 'hooks/querySuggestions/useFieldValuesSuggestion';
import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
import { DataSource } from 'types/common/queryBuilder';
import { GlobalReducer } from 'types/reducer/globalTime';
import { DATA_SOURCE_TO_SIGNAL, DataSource } from 'types/common/queryBuilder';
import { getValuesForDataType } from 'utils/fieldValues';
export interface Filters {
searchText: string;
attributeKey: string | string[];
aggregateOperator?: string;
dataSource?: DataSource;
aggregateAttribute?: string;
metricName?: string;
filterAttributeKeyDataType?: DataTypes;
tagType?: string;
fieldContext?: TelemetrytypesFieldContextDTO;
}
export interface GetAllFiltersResponse {
@@ -29,54 +27,41 @@ export function useGetAllFilters(props: Filters): GetAllFiltersResponse {
const {
searchText,
attributeKey,
aggregateOperator,
dataSource,
aggregateAttribute,
metricName,
filterAttributeKeyDataType,
tagType,
fieldContext,
} = props;
const { minTime, maxTime } = useSelector<AppState, GlobalReducer>(
(state) => state.globalTime,
);
const { data, isLoading } = useQuery(
[
REACT_QUERY_KEY.GET_ATTRIBUTE_VALUES,
dataSource,
metricName,
attributeKey,
fieldContext,
searchText,
minTime,
maxTime,
],
async () => {
const keys = Array.isArray(attributeKey) ? attributeKey : [attributeKey];
const responses = await Promise.all(
keys.map((key) =>
getAttributesValues({
aggregateOperator: aggregateOperator || 'noop',
dataSource: dataSource || DataSource.TRACES,
aggregateAttribute: aggregateAttribute || '',
attributeKey: key,
getFieldValueSuggestions({
signal: DATA_SOURCE_TO_SIGNAL[dataSource || DataSource.TRACES],
name: key,
fieldContext,
searchText: searchText ?? '',
filterAttributeKeyDataType:
filterAttributeKeyDataType || DataTypes.String,
tagType: tagType || 'tag',
metricName,
}),
),
);
const uniqueValues = [
...new Set(
responses.flatMap(({ payload }) => {
if (!payload) {
return [];
}
const dataType = filterAttributeKeyDataType || DataTypes.String;
const key = DATA_TYPE_VS_ATTRIBUTE_VALUES_KEY[dataType];
return key ? payload[key] || [] : [];
}),
responses.flatMap((response) =>
getValuesForDataType(toFieldValues(response), filterAttributeKeyDataType),
),
),
];
@@ -85,6 +70,7 @@ export function useGetAllFilters(props: Filters): GetAllFiltersResponse {
value: val,
}));
},
{ staleTime: FIELD_API_CACHE_TIME },
);
return { options: data ?? [], isFetching: isLoading };

View File

@@ -8,12 +8,9 @@ import { CardContainer } from 'container/WidgetCard/styles';
import { useIsDarkMode } from 'hooks/useDarkMode';
import { ChevronDown, ChevronUp } from '@signozhq/icons';
import { AppState } from 'store/reducers';
import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
import { DataSource } from 'types/common/queryBuilder';
import { GlobalReducer } from 'types/reducer/globalTime';
import { CaptureDataProps } from '../CeleryTaskDetail/CeleryTaskDetail';
import { useCeleryFilterOptions } from '../useCeleryFilterOptions';
import CeleryTaskBar from './CeleryTaskBar';
import CeleryTaskGraph from './CeleryTaskGraph';
import {
@@ -23,6 +20,7 @@ import {
celeryTasksByWorkerWidgetData,
} from './CeleryTaskGraphUtils';
import CeleryTaskLatencyGraph from './CeleryTaskLatencyGraph';
import { useCeleryWorkerCount } from './useCeleryWorkerCount';
import './CeleryTaskGraph.style.scss';
@@ -71,14 +69,7 @@ export default function CeleryTaskGraphGrid({
'Latency by worker',
];
const { options } = useCeleryFilterOptions(
'worker',
'rate',
DataSource.METRICS,
'flower_task_runtime_seconds_sum',
DataTypes.String,
'tag',
);
const { data: workerCount } = useCeleryWorkerCount();
const isDarkMode = useIsDarkMode();
const [collapsedSections, setCollapsedSections] = useState<{
@@ -151,8 +142,11 @@ export default function CeleryTaskGraphGrid({
</Typography.Text>
</div>
<div className="worker-count-text-container">
<Typography.Text className="celery-task-graph-worker-count-text">
{options.filter((option) => option.value).length}
<Typography.Text
className="celery-task-graph-worker-count-text"
data-testid="celery-worker-count"
>
{workerCount ?? '-'}
</Typography.Text>
</div>
</Card>

View File

@@ -1,3 +1,12 @@
import {
MetrictypesSpaceAggregationDTO,
MetrictypesTimeAggregationDTO,
Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5MetricAggregationDTOSignal as MetricSignal,
Querybuildertypesv5QueryEnvelopeBuilderDTOType,
type Querybuildertypesv5QueryRangeRequestDTO,
Querybuildertypesv5ReduceToDTO,
Querybuildertypesv5RequestTypeDTO,
} from 'api/generated/services/sigNoz.schemas';
import { PANEL_TYPES } from 'constants/queryBuilder';
import { getWidgetQueryBuilder } from 'container/MetricsApplication/MetricsApplication.factory';
import { getWidgetQuery } from 'pages/MessagingQueues/MQDetails/MetricPage/MetricPageUtil';
@@ -1042,3 +1051,34 @@ export const celeryRetryStateCountWidgetData = getWidgetQueryBuilder(
],
}),
);
// One row per worker that reported in the range; the card counts the rows.
export const getCeleryWorkerCountRequest = (
startTime: number,
endTime: number,
): Querybuildertypesv5QueryRangeRequestDTO => ({
schemaVersion: 'v1',
start: Math.floor(startTime / 1e6),
end: Math.floor(endTime / 1e6),
requestType: Querybuildertypesv5RequestTypeDTO.scalar,
compositeQuery: {
queries: [
{
type: Querybuildertypesv5QueryEnvelopeBuilderDTOType.builder_query,
spec: {
name: 'A',
signal: MetricSignal.metrics,
aggregations: [
{
metricName: 'flower_task_runtime_seconds_sum',
timeAggregation: MetrictypesTimeAggregationDTO.count,
spaceAggregation: MetrictypesSpaceAggregationDTO.sum,
reduceTo: Querybuildertypesv5ReduceToDTO.sum,
},
],
groupBy: [{ name: 'worker' }],
},
},
],
},
});

View File

@@ -0,0 +1,93 @@
import {
Querybuildertypesv5ColumnTypeDTO,
type Querybuildertypesv5QueryRangeRequestDTO,
Querybuildertypesv5RequestTypeDTO,
type QueryRangeV5200,
} from 'api/generated/services/sigNoz.schemas';
import { rest, server } from 'mocks-server/server';
import store from 'store';
import { render, screen, waitFor } from 'tests/test-utils';
import CeleryTaskGraphGrid from '../CeleryTaskGraphGrid';
const workerCountResponse = (workers: string[]): QueryRangeV5200 => ({
status: 'success',
data: {
type: Querybuildertypesv5RequestTypeDTO.scalar,
data: {
results: [
{
columns: [
{
name: 'worker',
queryName: 'A',
columnType: Querybuildertypesv5ColumnTypeDTO.group,
},
{
name: '__result_0',
queryName: 'A',
aggregationIndex: 0,
columnType: Querybuildertypesv5ColumnTypeDTO.aggregation,
},
],
data: workers.map((worker) => [worker, 4]),
},
],
},
},
});
describe('CeleryTaskGraphGrid worker count', () => {
let requests: Querybuildertypesv5QueryRangeRequestDTO[];
beforeEach(() => {
requests = [];
server.use(
rest.post('*/api/v5/query_range', async (req, res, ctx) => {
requests.push(await req.json());
return res(
ctx.status(200),
ctx.json(workerCountResponse(['worker-a', 'worker-b', ''])),
);
}),
);
});
it('counts the workers that reported in the selected range', async () => {
render(<CeleryTaskGraphGrid onClick={jest.fn()} queryEnabled={false} />);
await waitFor(() =>
expect(screen.getByTestId('celery-worker-count')).toHaveTextContent('2'),
);
const { minTime, maxTime } = store.getState().globalTime;
expect(requests).toStrictEqual([
{
schemaVersion: 'v1',
start: Math.floor(minTime / 1e6),
end: Math.floor(maxTime / 1e6),
requestType: 'scalar',
compositeQuery: {
queries: [
{
type: 'builder_query',
spec: {
name: 'A',
signal: 'metrics',
aggregations: [
{
metricName: 'flower_task_runtime_seconds_sum',
timeAggregation: 'count',
spaceAggregation: 'sum',
reduceTo: 'sum',
},
],
groupBy: [{ name: 'worker' }],
},
},
],
},
},
]);
});
});

View File

@@ -0,0 +1,31 @@
import { useMemo } from 'react';
import { useQuery, UseQueryResult } from 'react-query';
// eslint-disable-next-line no-restricted-imports
import { useSelector } from 'react-redux';
import { queryRangeV5 } from 'api/generated/services/querier';
import type { QueryRangeV5200 } from 'api/generated/services/sigNoz.schemas';
import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
import { getScalarResults } from 'pages/DashboardPage/DashboardContainer/queryV5/v5ResponseData';
import { AppState } from 'store/reducers';
import { GlobalReducer } from 'types/reducer/globalTime';
import { getCeleryWorkerCountRequest } from './CeleryTaskGraphUtils';
export function useCeleryWorkerCount(): UseQueryResult<number, Error> {
const { minTime, maxTime } = useSelector<AppState, GlobalReducer>(
(state) => state.globalTime,
);
const request = useMemo(
() => getCeleryWorkerCountRequest(minTime, maxTime),
[minTime, maxTime],
);
return useQuery<QueryRangeV5200, Error, number>({
queryKey: [REACT_QUERY_KEY.GET_CELERY_WORKER_COUNT, request],
queryFn: ({ signal }) => queryRangeV5(request, signal),
select: (response) =>
(getScalarResults(response)[0]?.data ?? []).filter(([worker]) => worker)
.length,
});
}

View File

@@ -1,18 +1,13 @@
import { useState } from 'react';
import type { DefaultOptionType } from 'antd/es/select';
import type { TelemetrytypesFieldContextDTO } from 'api/generated/services/sigNoz.schemas';
import useDebouncedFn from 'hooks/useDebouncedFunction';
import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
import { DataSource } from 'types/common/queryBuilder';
import { useGetAllFilters } from './CeleryTaskConfigOptions/useGetCeleryFilters';
export const useCeleryFilterOptions = (
type: string | string[],
aggregateOperator?: string,
dataSource?: DataSource,
aggregateAttribute?: string,
filterAttributeKeyDataType?: DataTypes,
tagType?: string,
fieldContext?: TelemetrytypesFieldContextDTO,
): {
searchText: string;
handleSearch: (value: string) => void;
@@ -23,11 +18,7 @@ export const useCeleryFilterOptions = (
const { isFetching, options } = useGetAllFilters({
attributeKey: type,
searchText,
aggregateOperator,
dataSource,
aggregateAttribute,
filterAttributeKeyDataType,
tagType,
fieldContext,
});
const handleDebouncedSearch = useDebouncedFn((searchText): void => {
setSearchText(searchText as string);

View File

@@ -1,5 +1,5 @@
import { TelemetrytypesFieldContextDTO } from 'api/generated/services/sigNoz.schemas';
import { TelemetryFieldKey } from 'types/api/v5/queryRange';
import { fieldContextToAttributeType } from 'utils/fieldContext';
import { fieldDataTypeToDataType } from 'utils/fieldDataType';
import { FiltersType, IQuickFiltersConfig } from './types';
@@ -14,19 +14,6 @@ const FILTER_TYPE_MAP: Record<string, FiltersType> = {
duration_nano: FiltersType.DURATION,
};
// The map below exists only for the old v3 attribute-values fetch
// (useCheckboxFilterValues), the sole reader of attributeKey.dataType/type.
// Once the values fetch moves to fields/values, remove this and reduce
// attributeKey to { id, key }.
const FIELD_CONTEXT_TO_ATTRIBUTE_TYPE: Record<string, string> = {
[TelemetrytypesFieldContextDTO.attribute]: 'tag',
[TelemetrytypesFieldContextDTO.resource]: 'resource',
};
const mapFieldContext = (fieldContext?: string): string =>
(fieldContext && FIELD_CONTEXT_TO_ATTRIBUTE_TYPE[fieldContext]) || '';
const getFilterName = (str: string): string => {
if (FILTER_TITLE_MAP[str]) {
return FILTER_TITLE_MAP[str];
@@ -61,11 +48,15 @@ export const getFilterConfig = (
({
type: getFilterType(att),
title: getFilterName(att.name),
// The type mapping below exists only for the old v3 attribute-values fetch
// (useCheckboxFilterValues), the sole reader of attributeKey.dataType/type.
// Once the values fetch moves to fields/values, remove this and reduce
// attributeKey to { id, key }.
attributeKey: {
id: att.name,
key: att.name,
dataType: fieldDataTypeToDataType(att.fieldDataType),
type: mapFieldContext(att.fieldContext),
type: fieldContextToAttributeType(att.fieldContext),
},
defaultOpen: index < 2,
}) as IQuickFiltersConfig,

View File

@@ -15,3 +15,5 @@ export const DASHBOARD_TIME_IN_DURATION = 'refreshInterval';
export const DEFAULT_ENTITY_VERSION = 'v3';
export const ENTITY_VERSION_V4 = 'v4';
export const ENTITY_VERSION_V5 = 'v5';
export const SIGNOZ_ADMIN_EMAIL = 'admin@signoz.cloud';

View File

@@ -109,6 +109,9 @@ export const REACT_QUERY_KEY = {
// Field Values Suggestion Query Keys
FIELD_VALUES_SUGGESTION: 'FIELD_VALUES_SUGGESTION',
// Celery Query Keys
GET_CELERY_WORKER_COUNT: 'GET_CELERY_WORKER_COUNT',
// AI Assistant Query Keys
AI_ASSISTANT_EMPTY_STATE_CHIPS: 'AI_ASSISTANT_EMPTY_STATE_CHIPS',
} as const;

View File

@@ -62,31 +62,7 @@ describe('ListAlertRules — actions menu', () => {
expect(labels).not.toContain('Disable');
});
it('toggle action: clicking Disable posts to the disable endpoint', async () => {
let disabledId: string | null = null;
server.use(
rest.post('http://localhost/api/v2/rules/:id/disable', (req, res, ctx) => {
disabledId = req.params.id as string;
return res(ctx.status(204));
}),
);
renderListAlertRules();
const row = await findAlertRow('High CPU Alert');
await openActionsMenu(row);
await clickMenuItem('Disable');
await waitFor(() => {
expect(disabledId).toBe('rule-1');
});
expect(logEventMock).toHaveBeenCalledWith(
'Alert: Action',
expect.objectContaining({ action: 'Enable/Disable', ruleId: 'rule-1' }),
);
});
it('toggle action: clicking Enable sends PATCH with disabled:false', async () => {
it('toggle action: clicking Disable sends PATCH with disabled:true', async () => {
let capturedBody: unknown = null;
let capturedPath: string | null = null;
server.use(
@@ -98,14 +74,21 @@ describe('ListAlertRules — actions menu', () => {
);
renderListAlertRules();
const row = await findAlertRow('Disabled Alert');
const row = await findAlertRow('High CPU Alert');
await openActionsMenu(row);
await clickMenuItem('Enable');
await clickMenuItem('Disable');
await waitFor(() => {
expect(capturedBody).toStrictEqual({ disabled: false });
expect(capturedBody).toStrictEqual(
expect.objectContaining({ disabled: true }),
);
});
expect(capturedPath).toBe('rule-4');
expect(capturedPath).toBe('rule-1');
expect(logEventMock).toHaveBeenCalledWith(
'Alert: Action',
expect.objectContaining({ action: 'Enable/Disable', ruleId: 'rule-1' }),
);
});
it('edit action: clicking Edit navigates via safeNavigate and logs event', async () => {
@@ -209,11 +192,11 @@ describe('ListAlertRules — actions menu', () => {
);
});
it('error path: disable is still attempted when server returns 500', async () => {
let disableAttempted = false;
it('error path: PATCH is still attempted when server returns 500', async () => {
let patchAttempted = false;
server.use(
rest.post('http://localhost/api/v2/rules/:id/disable', (_, res, ctx) => {
disableAttempted = true;
rest.patch('http://localhost/api/v2/rules/:id', (_, res, ctx) => {
patchAttempted = true;
return res(ctx.status(500), ctx.json({ status: 'error' }));
}),
);
@@ -224,7 +207,7 @@ describe('ListAlertRules — actions menu', () => {
await clickMenuItem('Disable');
await waitFor(() => {
expect(disableAttempted).toBe(true);
expect(patchAttempted).toBe(true);
});
expect(logEventMock).toHaveBeenCalledWith(

View File

@@ -4,15 +4,17 @@ import { Ellipsis } from '@signozhq/icons';
import { Button } from '@signozhq/ui/button';
import { Dropdown, type DropdownItemType } from '@signozhq/ui/dropdown';
import { toast } from '@signozhq/ui/sonner';
import { patchRulePartial } from 'api/alerts/patchRulePartial';
import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
import {
deleteRuleByID,
disableRuleByID,
invalidateListRulesV3,
patchRuleByID,
cloneRuleByID,
} from 'api/generated/services/rules';
import type { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
import type {
RenderErrorResponseDTO,
RuletypesPostableRuleDTO,
} from 'api/generated/services/sigNoz.schemas';
import type { AxiosError } from 'axios';
import type { AlertRule } from '../types';
@@ -29,12 +31,12 @@ function ActionsMenu({ rule, onEdit }: ActionsMenuProps): JSX.Element {
const handleToggle = useCallback((): void => {
alertActionLogEvent(ALERT_ACTIONS.TOGGLE, rule);
const newDisabled = !rule.disabled;
const id = rule.id ?? '';
const toggleRequest: Promise<unknown> = newDisabled
? disableRuleByID({ id })
: patchRulePartial(id, { disabled: false });
toast.promise(
toggleRequest.then(() => invalidateListRulesV3(queryClient)),
patchRuleByID({ id: rule.id ?? '' }, {
disabled: newDisabled,
} as RuletypesPostableRuleDTO).then(() =>
invalidateListRulesV3(queryClient),
),
{
loading: newDisabled ? 'Disabling alert...' : 'Enabling alert...',
success: newDisabled ? 'Alert disabled' : 'Alert enabled',

View File

@@ -0,0 +1,70 @@
import { Form } from 'antd';
import QueryBuilderSearchV2 from 'container/QueryBuilder/filters/QueryBuilderSearchV2/QueryBuilderSearchV2';
import { rest, server } from 'mocks-server/server';
import { act, render, waitFor } from 'tests/test-utils';
import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
import type { QueryRangePayload } from 'types/api/metrics/getQueryRange';
import type {
IBuilderQuery,
TagFilter,
} from 'types/api/queryBuilder/queryBuilderData';
import { pipelineFields } from '../../../../config';
import FilterInput from '..';
jest.mock(
'container/QueryBuilder/filters/QueryBuilderSearchV2/QueryBuilderSearchV2',
() => ({ __esModule: true, default: jest.fn(() => null) }),
);
const filterField = pipelineFields.find((field) => field.name === 'filter');
const v5Filter: TagFilter = {
op: 'AND',
items: [
{
id: 'attribute-pill',
key: { key: 'http.method', dataType: DataTypes.String, type: 'attribute' },
op: '=',
value: 'GET',
},
{
id: 'log-pill',
key: { key: 'severity_text', dataType: DataTypes.String, type: 'log' },
op: '=',
value: 'ERROR',
},
],
};
describe('Pipeline FilterInput', () => {
it('previews sample logs with the legacy key types the v3 logs builder reads', async () => {
const previewFilters: TagFilter[] = [];
server.use(
rest.post('*/api/v3/query_range', async (req, res, ctx) => {
const body: QueryRangePayload = await req.json();
const query = body.compositeQuery.builderQueries?.A as IBuilderQuery;
if (query.filters) {
previewFilters.push(query.filters);
}
return res(ctx.status(200), ctx.json({ data: { result: [] } }));
}),
);
render(<Form>{filterField && <FilterInput fieldData={filterField} />}</Form>);
const { onChange } = jest.mocked(QueryBuilderSearchV2).mock.calls[0][0];
act(() => onChange(v5Filter));
await waitFor(() => expect(previewFilters).not.toHaveLength(0));
expect(
previewFilters[previewFilters.length - 1].items.map((item) => [
item.key?.key,
item.key?.type,
]),
).toStrictEqual([
['http.method', 'tag'],
['severity_text', ''],
]);
});
});

View File

@@ -4,6 +4,7 @@ import { initialQueryBuilderFormValuesMap } from 'constants/queryBuilder';
import QueryBuilderSearchV2 from 'container/QueryBuilder/filters/QueryBuilderSearchV2/QueryBuilderSearchV2';
import isEqual from 'lodash-es/isEqual';
import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
import { toLegacyLogsFilter } from 'utils/fieldContext';
import { ProcessorFormField } from '../../../AddNewProcessor/config';
import { formValidationRules } from '../../../config';
@@ -22,9 +23,10 @@ function TagFilterInput({
}
const onQueryChange = (newValue: TagFilter): void => {
const legacyValue = toLegacyLogsFilter(newValue);
// Avoid unnecessary onChange calls
if (!isEqual(newValue, query.filters)) {
onChange(newValue);
if (!isEqual(legacyValue, query.filters)) {
onChange(legacyValue);
}
};

View File

@@ -10,7 +10,6 @@ import {
userEvent,
waitFor,
} from 'tests/test-utils';
import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
import { pipelineApiResponseMockData } from '../mocks/pipeline';
import PipelineListsView from '../PipelineListsView';
@@ -85,7 +84,7 @@ jest.mock('providers/preferences/sync/usePreferenceSync', () => ({
}));
const BASE_URL = ENVIRONMENT.baseURL;
const attributeKeysURL = `${BASE_URL}/api/v3/filter_suggestions`;
const fieldKeysURL = `${BASE_URL}/api/v1/fields/keys`;
describe('PipelinePage container test', () => {
beforeAll(() => {
@@ -339,42 +338,41 @@ describe('PipelinePage container test', () => {
expect(screen.queryAllByText('source = nginx')).toHaveLength(2);
server.use(
rest.get(attributeKeysURL, (_req, res, ctx) =>
rest.get(fieldKeysURL, (_req, res, ctx) =>
res(
ctx.status(200),
ctx.json({
status: 'success',
data: {
attributes: [
{
key: 'otelServiceName',
dataType: DataTypes.String,
type: 'tag',
isColumn: false,
isJSON: false,
},
{
key: 'service.name',
dataType: DataTypes.String,
type: 'resource',
isColumn: false,
isJSON: false,
},
{
key: 'service.instance.id',
dataType: DataTypes.String,
type: 'resource',
isColumn: false,
isJSON: false,
},
{
key: 'service.name',
dataType: DataTypes.String,
type: 'tag',
isColumn: false,
isJSON: false,
},
],
complete: true,
keys: {
otelServiceName: [
{
name: 'otelServiceName',
fieldContext: 'attribute',
fieldDataType: 'string',
},
],
'service.name': [
{
name: 'service.name',
fieldContext: 'resource',
fieldDataType: 'string',
},
{
name: 'service.name',
fieldContext: 'attribute',
fieldDataType: 'string',
},
],
'service.instance.id': [
{
name: 'service.instance.id',
fieldContext: 'resource',
fieldDataType: 'string',
},
],
},
},
}),
),

View File

@@ -10,9 +10,9 @@ import {
} from 'react';
import { type RefSelectProps, Select, Spin } from 'antd';
import { Pill } from '@signozhq/ui/pill';
import { TelemetrytypesFieldContextDTO } from 'api/generated/services/sigNoz.schemas';
import cx from 'classnames';
import {
DATA_TYPE_VS_ATTRIBUTE_VALUES_KEY,
OperatorConfigKeys,
OPERATORS,
QUERY_BUILDER_OPERATORS_BY_TYPES,
@@ -22,23 +22,14 @@ import { DEBOUNCE_DELAY } from 'constants/queryBuilderFilterConfig';
import { LogsExplorerShortcuts } from 'constants/shortcuts/logsExplorerShortcuts';
import { useDynamicVariableSuggestions } from 'hooks/dashboard/useDynamicVariableSuggestions';
import { useKeyboardHotkeys } from 'hooks/hotkeys/useKeyboardHotkeys';
import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
import { useGetAggregateValues } from 'hooks/queryBuilder/useGetAggregateValues';
import { useGetAttributeSuggestions } from 'hooks/queryBuilder/useGetAttributeSuggestions';
import { validationMapper } from 'hooks/queryBuilder/useIsValidTag';
import { operatorTypeMapper } from 'hooks/queryBuilder/useOperatorType';
import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
import { useRunQueryWithFilterItems } from 'hooks/queryBuilder/useRunQueryWithFilterItems';
import { useFieldKeysSuggestion } from 'hooks/querySuggestions/useFieldKeysSuggestion';
import { useFieldValuesSuggestion } from 'hooks/querySuggestions/useFieldValuesSuggestion';
import useDebounceValue from 'hooks/useDebounce';
import {
cloneDeep,
isArray,
isEmpty,
isEqual,
isObject,
isUndefined,
unset,
} from 'lodash-es';
import { isArray, isEmpty, isEqual, isObject, isUndefined } from 'lodash-es';
import { ChevronDown, ChevronUp } from '@signozhq/icons';
import {
BaseAutocompleteData,
@@ -48,7 +39,13 @@ import {
IBuilderQuery,
TagFilter,
} from 'types/api/queryBuilder/queryBuilderData';
import { DataSource } from 'types/common/queryBuilder';
import {
DATA_SOURCE_TO_SIGNAL,
DataSource,
QUERY_SOURCE_TO_FIELD_SOURCE,
} from 'types/common/queryBuilder';
import { attributeTypeToFieldContext } from 'utils/fieldContext';
import { getValuesForDataType } from 'utils/fieldValues';
import { useSelectPopupContainer } from 'utils/selectPopupContainer';
import { v4 as uuid } from 'uuid';
@@ -61,7 +58,8 @@ import {
getTagToken,
isInNInOperator,
} from './utils';
import { filterByOperatorConfig } from '../utils';
import { toAttributeKey } from '../GroupByFilter/utils';
import { filterByOperatorConfig, getMetricNameForQuery } from '../utils';
import QueryBuilderSearchDropdown from './QueryBuilderSearchDropdown';
import SpanScopeSelector from './SpanScopeSelector';
import Suggestions from './Suggestions';
@@ -75,6 +73,8 @@ export interface ITag {
value: (string | number | boolean)[] | string | number | boolean;
}
const SPAN_SEARCH_SCOPE_KEYS = ['isRoot', 'isEntryPoint'];
interface CustomTagProps {
label: React.ReactNode;
value: string;
@@ -186,70 +186,15 @@ function QueryBuilderSearchV2(
[query.dataSource],
);
const memoizedSearchParams = useMemo(
() => [
searchValue,
query.dataSource,
query.aggregateOperator,
query.aggregateAttribute?.key,
],
[
searchValue,
query.dataSource,
query.aggregateOperator,
query.aggregateAttribute?.key,
],
);
const queryFiltersWithoutId = useMemo(
() => ({
...query.filters,
items: query.filters?.items.map((item) => {
const filterWithoutId = cloneDeep(item);
unset(filterWithoutId, 'id');
return filterWithoutId;
}),
}),
[query.filters],
);
const memoizedSuggestionsParams = useMemo(
() => [searchValue, query.dataSource, queryFiltersWithoutId],
[query.dataSource, queryFiltersWithoutId, searchValue],
);
const memoizedValueParams = useMemo(
() => [
query.aggregateOperator,
query.dataSource,
query.aggregateAttribute?.key,
currentFilterItem?.key?.key || '',
currentFilterItem?.key?.dataType,
currentFilterItem?.key?.type ?? '',
isArray(currentFilterItem?.value)
? currentFilterItem?.value?.[currentFilterItem.value.length - 1]
: currentFilterItem?.value,
],
[
query.aggregateOperator,
query.dataSource,
query.aggregateAttribute?.key,
currentFilterItem?.key?.key,
currentFilterItem?.key?.dataType,
currentFilterItem?.key?.type,
currentFilterItem?.value,
],
);
const searchParams = useDebounceValue(memoizedSearchParams, DEBOUNCE_DELAY);
const valueParams = useDebounceValue(memoizedValueParams, DEBOUNCE_DELAY);
const suggestionsParams = useDebounceValue(
memoizedSuggestionsParams,
const debouncedKeySearchText = useDebounceValue(
searchValue?.split(' ')[0] ?? '',
DEBOUNCE_DELAY,
);
const valueSearchText = isArray(currentFilterItem?.value)
? String(currentFilterItem?.value?.[currentFilterItem.value.length - 1] ?? '')
: currentFilterItem?.value?.toString() || '';
const isQueryEnabled = useMemo(() => {
if (currentState === DropdownState.ATTRIBUTE_KEY) {
return query.dataSource === DataSource.METRICS
@@ -262,53 +207,76 @@ function QueryBuilderSearchV2(
const dashboardDynamicVariables = useDynamicVariableSuggestions();
const { data, isFetching } = useGetAggregateKeys(
const signal = DATA_SOURCE_TO_SIGNAL[query.dataSource];
const source = QUERY_SOURCE_TO_FIELD_SOURCE[query.source ?? ''];
const metricName = getMetricNameForQuery(query);
const { data: fieldKeys, isFetching } = useFieldKeysSuggestion(
{
searchText: searchValue?.split(' ')[0],
dataSource: query.dataSource,
aggregateOperator: query.aggregateOperator || '',
aggregateAttribute: query.aggregateAttribute?.key || '',
tagType: query.aggregateAttribute?.type ?? null,
signal,
source,
metricName,
fieldContext: attributeTypeToFieldContext(query.aggregateAttribute?.type),
searchText: debouncedKeySearchText,
},
query.builderQueryType,
{
queryKey: [searchParams],
enabled: isQueryEnabled && !isLogsDataSource && !hardcodedAttributeKeys,
enabled: isQueryEnabled && !hardcodedAttributeKeys,
keepPreviousData: true,
},
);
const { data: suggestionsData, isFetching: isFetchingSuggestions } =
useGetAttributeSuggestions(
{
searchText: searchValue?.split(' ')[0],
dataSource: query.dataSource,
filters: query.filters || { items: [], op: 'AND' },
},
{
queryKey: [suggestionsParams],
enabled: isQueryEnabled && isLogsDataSource,
},
);
// The legacy traces builder checks `exists` on the column only for keys marked as columns.
// Body JSON keys come back as bare paths, which the legacy builders read as top-level fields,
// and the span search scope selectors are not columns the legacy filter builder can read.
const attributeKeys = useMemo(
() =>
(fieldKeys ?? [])
.filter(
(fieldKey) =>
fieldKey.fieldContext !== TelemetrytypesFieldContextDTO.body &&
!(
fieldKey.fieldContext === TelemetrytypesFieldContextDTO.span &&
SPAN_SEARCH_SCOPE_KEYS.includes(fieldKey.name)
),
)
.map((fieldKey) => ({
...toAttributeKey(fieldKey),
isColumn:
fieldKey.fieldContext === TelemetrytypesFieldContextDTO.span ||
fieldKey.fieldContext === TelemetrytypesFieldContextDTO.log,
})),
[fieldKeys],
);
const { data: attributeValues, isFetching: isFetchingAttributeValues } =
useGetAggregateValues(
{
aggregateOperator: query.aggregateOperator || '',
dataSource: query.dataSource,
aggregateAttribute: query.aggregateAttribute?.key || '',
attributeKey: currentFilterItem?.key?.key || '',
filterAttributeKeyDataType:
currentFilterItem?.key?.dataType ?? DataTypes.EMPTY,
tagType: currentFilterItem?.key?.type ?? '',
searchText: isArray(currentFilterItem?.value)
? String(currentFilterItem?.value?.[currentFilterItem.value.length - 1]) ||
''
: currentFilterItem?.value?.toString() || '',
},
{
enabled: currentState === DropdownState.ATTRIBUTE_VALUE,
queryKey: [valueParams],
},
);
const fieldValuesConfig = useMemo(
() => ({
signal,
source,
metricName,
name: currentFilterItem?.key?.key || '',
fieldContext: attributeTypeToFieldContext(currentFilterItem?.key?.type),
searchText: valueSearchText,
}),
[
signal,
source,
metricName,
currentFilterItem?.key?.key,
currentFilterItem?.key?.type,
valueSearchText,
],
);
const debouncedFieldValuesConfig = useDebounceValue(
fieldValuesConfig,
DEBOUNCE_DELAY,
);
const { data: fieldValues, isFetching: isFetchingAttributeValues } =
useFieldValuesSuggestion(debouncedFieldValuesConfig, query.builderQueryType, {
enabled: currentState === DropdownState.ATTRIBUTE_VALUE,
});
const handleDropdownSelect = useCallback(
(value: string) => {
@@ -533,15 +501,13 @@ function QueryBuilderSearchV2(
if (tagKey && isUndefined(currentFilterItem?.key)) {
let currentRunningAttributeKey;
const isSuggestedKeyInAutocomplete =
suggestionsData?.payload?.attributes?.some(
(value) => value.key === tagKey.split(' ')[0],
);
isLogsDataSource &&
attributeKeys.some((value) => value.key === tagKey.split(' ')[0]);
if (isSuggestedKeyInAutocomplete) {
const allAttributesMatchingTheKey =
suggestionsData?.payload?.attributes?.filter(
(value) => value.key === tagKey.split(' ')[0],
) || [];
const allAttributesMatchingTheKey = attributeKeys.filter(
(value) => value.key === tagKey.split(' ')[0],
);
if (allAttributesMatchingTheKey?.length === 1) {
[currentRunningAttributeKey] = allAttributesMatchingTheKey;
@@ -648,9 +614,10 @@ function QueryBuilderSearchV2(
currentFilterItem,
currentFilterItem?.key,
currentFilterItem?.op,
suggestionsData?.payload?.attributes,
attributeKeys,
isLogsDataSource,
searchValue,
isFetchingSuggestions,
isFetching,
currentState,
]);
@@ -662,9 +629,7 @@ function QueryBuilderSearchV2(
// add the user typed option in the dropdown to select that and move ahead irrespective of the matches and all
setDropdownOptions([
...(!isEmpty(tagKey) &&
!suggestionsData?.payload?.attributes?.some((val) =>
isEqual(val.key, tagKey),
)
!attributeKeys.some((val) => isEqual(val.key, tagKey))
? [
{
label: tagKey,
@@ -676,10 +641,10 @@ function QueryBuilderSearchV2(
},
]
: []),
...(suggestionsData?.payload?.attributes?.map((key) => ({
...attributeKeys.map((key) => ({
label: key.key,
value: key,
})) || []),
})),
]);
} else if (hardcodedAttributeKeys) {
const filteredKeys = hardcodedAttributeKeys.filter((key) =>
@@ -697,7 +662,7 @@ function QueryBuilderSearchV2(
setDropdownOptions([
// Add user typed option if it doesn't exist in the payload
...(tagKey.trim().length > 0 &&
!data?.payload?.attributeKeys?.some((val) => val.key === tagKey)
!attributeKeys.some((val) => val.key === tagKey)
? [
{
label: tagKey,
@@ -710,10 +675,10 @@ function QueryBuilderSearchV2(
]
: []),
// Map existing attribute keys from payload
...(data?.payload?.attributeKeys?.map((key) => ({
...attributeKeys.map((key) => ({
label: key.key,
value: key,
})) || []),
})),
]);
}
}
@@ -778,10 +743,10 @@ function QueryBuilderSearchV2(
values.push(tagValue);
}
if (attributeValues?.payload) {
const dataType = currentFilterItem?.key?.dataType || DataTypes.String;
const key = DATA_TYPE_VS_ATTRIBUTE_VALUES_KEY[dataType];
values.push(...(attributeValues?.payload?.[key] || []));
if (fieldValues) {
values.push(
...getValuesForDataType(fieldValues, currentFilterItem?.key?.dataType),
);
// here we want to suggest the variable name matching with the key here, we will go over the dynamic variables for the keys
const variableName = dashboardDynamicVariables.find(
@@ -805,13 +770,12 @@ function QueryBuilderSearchV2(
}
}, [
hardcodedAttributeKeys,
attributeValues?.payload,
fieldValues,
currentFilterItem?.key?.dataType,
currentState,
data?.payload?.attributeKeys,
attributeKeys,
isLogsDataSource,
searchValue,
suggestionsData?.payload?.attributes,
operatorConfigKey,
currentFilterItem?.key?.key,
dashboardDynamicVariables,
@@ -880,8 +844,8 @@ function QueryBuilderSearchV2(
}, [deregisterShortcut, isLastQuery, registerShortcut]);
const loading = useMemo(
() => isFetching || isFetchingAttributeValues || isFetchingSuggestions,
[isFetching, isFetchingAttributeValues, isFetchingSuggestions],
() => isFetching || isFetchingAttributeValues,
[isFetching, isFetchingAttributeValues],
);
const isMetricsDataSource = useMemo(
@@ -991,7 +955,7 @@ function QueryBuilderSearchV2(
setTags((prev) => [...prev, ...(val.items as ITag[])]);
}}
searchValue={searchValue}
exampleQueries={suggestionsData?.payload?.example_queries || []}
exampleQueries={[]}
tags={tags}
currentFilterItem={currentFilterItem}
isLogsDataSource={isLogsDataSource}

View File

@@ -1,13 +1,23 @@
import { QueryClient, QueryClientProvider } from 'react-query';
import { render, RenderResult, screen, within } from '@testing-library/react';
import {
render,
RenderResult,
screen,
waitFor,
within,
} from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import {
initialQueriesMap,
initialQueryBuilderFormValues,
} from 'constants/queryBuilder';
import { TelemetrytypesTelemetryFieldValuesDTO } from 'api/generated/services/sigNoz.schemas';
import { DynamicVariableSuggestion } from 'providers/Dashboard/store/dynamicVariableSuggestions';
import { useFieldKeysSuggestion } from 'hooks/querySuggestions/useFieldKeysSuggestion';
import { useFieldValuesSuggestion } from 'hooks/querySuggestions/useFieldValuesSuggestion';
import { QueryBuilderContext } from 'providers/QueryBuilder';
import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
import { FieldDataType, TelemetryFieldKey } from 'types/api/v5/queryRange';
import { DataSource } from 'types/common/queryBuilder';
import QueryBuilderSearchV2 from '../QueryBuilderSearchV2';
@@ -88,57 +98,34 @@ const renderWithContext = (props = {}): RenderResult => {
const getSearchCombobox = (): HTMLElement =>
within(screen.getByTestId('qb-search-select')).getByRole('combobox');
// Constants to fix linter errors
const TYPE_TAG = 'tag';
const IS_COLUMN_FALSE = false;
const IS_JSON_FALSE = false;
const mockAggregateKeysData = {
payload: {
attributeKeys: [
{
key: 'http.status',
dataType: DataTypes.String,
type: TYPE_TAG,
id: 'http.status--string--tag--false',
},
{
key: 'service.name',
dataType: DataTypes.String,
type: TYPE_TAG,
isColumn: IS_COLUMN_FALSE,
isJSON: IS_JSON_FALSE,
id: 'service.name--string--tag--false',
},
{
key: 'unmapped.attribute',
dataType: 'not-a-real-data-type' as unknown as DataTypes,
type: TYPE_TAG,
isColumn: IS_COLUMN_FALSE,
isJSON: IS_JSON_FALSE,
id: 'unmapped.attribute--String--tag--false',
},
],
const mockFieldKeys: TelemetryFieldKey[] = [
{ name: 'http.status', fieldContext: 'attribute', fieldDataType: 'string' },
{ name: 'service.name', fieldContext: 'attribute', fieldDataType: 'string' },
{ name: 'name', fieldContext: 'span', fieldDataType: 'string' },
{ name: 'user.id', fieldContext: 'body', fieldDataType: 'string' },
{ name: 'isRoot', fieldContext: 'span', fieldDataType: 'bool' },
{
name: 'unmapped.attribute',
fieldContext: 'attribute',
fieldDataType: 'not-a-real-data-type' as FieldDataType,
},
};
];
jest.mock('hooks/queryBuilder/useGetAggregateKeys', () => ({
useGetAggregateKeys: jest.fn(() => ({
data: mockAggregateKeysData,
jest.mock('hooks/querySuggestions/useFieldKeysSuggestion', () => ({
useFieldKeysSuggestion: jest.fn(() => ({
data: mockFieldKeys,
isFetching: false,
})),
}));
const mockAggregateValuesData = {
payload: {
stringAttributeValues: ['200', '404', '500'],
numberAttributeValues: [200, 404, 500],
},
const mockFieldValues: TelemetrytypesTelemetryFieldValuesDTO = {
stringValues: ['200', '404', '500'],
numberValues: [200, 404, 500],
};
jest.mock('hooks/queryBuilder/useGetAggregateValues', () => ({
useGetAggregateValues: jest.fn(() => ({
data: mockAggregateValuesData,
jest.mock('hooks/querySuggestions/useFieldValuesSuggestion', () => ({
useFieldValuesSuggestion: jest.fn(() => ({
data: mockFieldValues,
isFetching: false,
})),
}));
@@ -196,7 +183,11 @@ describe('Suggestion Key -> Operator -> Value Flow', () => {
expect.objectContaining({
items: expect.arrayContaining([
expect.objectContaining({
key: expect.objectContaining({ key: 'http.status' }),
key: expect.objectContaining({
key: 'http.status',
type: 'attribute',
dataType: 'string',
}),
op: '=',
value: '200',
}),
@@ -292,7 +283,7 @@ describe('Filter chips', () => {
key: {
key: 'http.status',
dataType: DataTypes.String,
type: TYPE_TAG,
type: 'tag',
id: 'http.status--string--tag--false',
},
op: '=',
@@ -332,3 +323,87 @@ describe('Filter chips', () => {
expect(getSearchCombobox()).toHaveDisplayValue(CHIP_LABEL);
});
});
describe('Key fetch context', () => {
it('limits keys to the aggregate attribute context, as the resource filter needs', () => {
renderWithContext({
query: {
...defaultProps.query,
aggregateAttribute: {
...defaultProps.query.aggregateAttribute,
type: 'resource',
},
},
});
expect(useFieldKeysSuggestion).toHaveBeenLastCalledWith(
expect.objectContaining({ fieldContext: 'resource' }),
undefined,
expect.anything(),
);
});
it('fetches keys from every context when the aggregate attribute has no type', () => {
renderWithContext();
expect(useFieldKeysSuggestion).toHaveBeenLastCalledWith(
expect.objectContaining({ fieldContext: undefined }),
undefined,
expect.anything(),
);
});
});
describe('Keys the legacy filter builders cannot read', () => {
it('does not suggest body JSON keys or span search scope selectors', async () => {
const user = userEvent.setup({ delay: null });
renderWithContext();
const combobox = getSearchCombobox();
await user.click(combobox);
await user.type(combobox, 'user');
await screen.findByRole('listbox');
await expect(screen.findByText('http.status')).resolves.toBeInTheDocument();
expect(screen.queryByText('user.id')).not.toBeInTheDocument();
expect(screen.queryByText('isRoot')).not.toBeInTheDocument();
});
});
describe('Span field keys', () => {
it('marks span fields as columns and looks up their values in the span context', async () => {
const user = userEvent.setup({ delay: null });
renderWithContext();
const combobox = getSearchCombobox();
await user.click(combobox);
await user.type(combobox, 'nam');
await screen.findByRole('listbox');
await user.click(await screen.findByText('name'));
await user.click(screen.getByText('='));
await waitFor(() =>
expect(jest.mocked(useFieldValuesSuggestion)).toHaveBeenLastCalledWith(
expect.objectContaining({ name: 'name', fieldContext: 'span' }),
undefined,
expect.anything(),
),
);
await user.click(screen.getByText('200'));
expect(mockOnChange).toHaveBeenLastCalledWith(
expect.objectContaining({
items: expect.arrayContaining([
expect.objectContaining({
key: expect.objectContaining({
key: 'name',
type: 'span',
isColumn: true,
}),
}),
]),
}),
);
});
});

View File

@@ -290,9 +290,6 @@ export const handlers = [
rest.patch('http://localhost/api/v2/rules/:id', (_, res, ctx) =>
res(ctx.status(200), ctx.json({ status: 'success' })),
),
rest.post('http://localhost/api/v2/rules/:id/disable', (_, res, ctx) =>
res(ctx.status(204)),
),
rest.delete('http://localhost/api/v2/rules/:id', (_, res, ctx) =>
res(ctx.status(200), ctx.json({ status: 'success' })),
),

View File

@@ -7,7 +7,6 @@ import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
import {
cloneRuleByID,
deleteRuleByID,
disableRuleByID,
getGetRuleHistoryTimelineQueryOptions,
invalidateGetRuleByID,
invalidateListRulesV3,
@@ -25,6 +24,7 @@ import {
type GetRuleHistoryTimeline200,
type GetRuleHistoryTopContributors200,
type RenderErrorResponseDTO,
type RuletypesPostableRuleDTO,
} from 'api/generated/services/sigNoz.schemas';
import { AxiosError } from 'axios';
import { QueryParams } from 'constants/query';
@@ -378,17 +378,11 @@ export const useAlertRuleStatusToggle = ({
const { mutate: toggleAlertState } = useMutation(
[REACT_QUERY_KEY.TOGGLE_ALERT_STATE, ruleId],
async (args: { id: string; disabled: boolean }) => {
if (args.disabled) {
await disableRuleByID({ id: args.id });
return RuletypesAlertStateDTO.disabled;
}
const response = await patchRulePartial(args.id, { disabled: false });
return response.data.state;
},
(args: { id: string; data: Partial<RuletypesPostableRuleDTO> }) =>
patchRulePartial(args.id, args.data),
{
onSuccess: (state) => {
setAlertRuleState(state);
onSuccess: (data) => {
setAlertRuleState(data.data.state);
void invalidateGetRuleByID(queryClient, { id: ruleId });
void queryClient.refetchQueries([
REACT_QUERY_KEY.ALERT_RULE_DETAILS,
@@ -396,7 +390,7 @@ export const useAlertRuleStatusToggle = ({
]);
notifications.success({
message: `Alert has been ${
state === RuletypesAlertStateDTO.disabled ? 'disabled' : 'enabled'
data.data.state === 'disabled' ? 'disabled' : 'enabled'
}.`,
});
},
@@ -414,10 +408,11 @@ export const useAlertRuleStatusToggle = ({
);
const handleAlertStateToggle = (): void => {
toggleAlertState({
const args = {
id: ruleId,
disabled: alertRuleState !== RuletypesAlertStateDTO.disabled,
});
data: { disabled: alertRuleState !== 'disabled' },
};
toggleAlertState(args);
};
return { handleAlertStateToggle };

View File

@@ -98,10 +98,6 @@ export const alertOverviewMocks = defineStoryMocks({
res(ctx.status(200), ctx.json({ status: 'success', data: null })),
),
rest.post('http://localhost/api/v2/rules/:id/disable', (_req, res, ctx) =>
res(ctx.status(204)),
),
rest.delete('http://localhost/api/v2/rules/:id', (_req, res, ctx) =>
res(ctx.status(200), ctx.json({ status: 'success', data: null })),
),

View File

@@ -246,12 +246,6 @@ export const alertRulesMocks = defineStoryMocks({
})),
),
rest.post('http://localhost/api/v2/rules/:id/disable', (_req, res, ctx) =>
values.toggleState === 'success'
? res(ctx.status(204))
: actionResponse(values.toggleState, res, ctx, () => null),
),
rest.post('http://localhost/api/v2/rules/:id/clone', (_req, res, ctx) =>
actionResponse(values.cloneState, res, ctx, () => ({
status: 'success',

View File

@@ -24,7 +24,6 @@ import { fieldValuesResponse } from '@/storybook/msw/__story_mockdata__/fields';
import {
EXCEPTION_CATALOGUE_SIZE,
EXCEPTION_QUICK_FILTER_CAP,
exceptionAttributeKeysResponse,
exceptionAttributeValuesResponse,
exceptionFieldKeysResponse,
exceptionQuickFiltersResponse,
@@ -58,7 +57,7 @@ export const exceptionsMocks = defineStoryMocks({
filterKeys: choiceControl<ResponseState>('Filter keys', {
group: FILTERS,
description:
'How `/autocomplete/attribute_keys` answers when the resource filter opens, apart from the page-wide Data control.',
'How `/fields/keys` answers when the resource filter opens, apart from the page-wide Data control.',
options: RESPONSE_STATES,
value: 'loaded',
}),
@@ -95,7 +94,7 @@ export const exceptionsMocks = defineStoryMocks({
rest.get(
'http://localhost/api/v1/fields/keys',
response.json((req) =>
respondWith(values.filterKeys, (req) =>
exceptionFieldKeysResponse(req.url.searchParams.get('searchText')),
),
),
@@ -109,23 +108,6 @@ export const exceptionsMocks = defineStoryMocks({
),
),
),
rest.get(
'http://localhost/api/v3/autocomplete/attribute_keys',
respondWith(values.filterKeys, (req) =>
exceptionAttributeKeysResponse(req.url.searchParams.get('searchText')),
),
),
rest.get(
'http://localhost/api/v3/autocomplete/attribute_values',
response.json((req) =>
exceptionAttributeValuesResponse(
req.url.searchParams.get('attributeKey'),
req.url.searchParams.get('searchText'),
),
),
),
],
effect: (values) => {
set(LOCALSTORAGE.SHOW_EXCEPTIONS_QUICK_FILTERS, String(values.filterPanel));

View File

@@ -17,7 +17,6 @@ import type {
import {
type BaseAutocompleteData,
DataTypes,
type IQueryAutocompleteResponse,
} from 'types/api/queryBuilder/queryAutocompleteResponse';
import type { Exception, Order, OrderBy } from 'types/api/errors/getAll';
import type { IAttributeValuesResponse } from 'types/api/queryBuilder/getAttributesValues';
@@ -311,21 +310,6 @@ const ATTRIBUTE_KEYS: BaseAutocompleteData[] = [
{ key: 'cloud.region', dataType: DataTypes.String, type: 'resource' },
];
export const exceptionAttributeKeysResponse = (
searchText: string | null,
): { status: string; data: IQueryAutocompleteResponse } => {
const search = (searchText ?? '').toLowerCase();
return {
status: 'success',
data: {
attributeKeys: ATTRIBUTE_KEYS.filter(({ key }) =>
key.toLowerCase().includes(search),
),
},
};
};
/** The quick filter settings panel lists its "other filters" from `/fields/keys`. */
export const exceptionFieldKeysResponse = (
searchText: string | null,

View File

@@ -9,6 +9,8 @@ import type { QueryRangePayload } from 'types/api/metrics/getQueryRange';
import { choiceControl, countControl } from '@/storybook/controls/controls';
import { defineStoryMocks } from '@/storybook/controls/defineStoryMocks';
import { fieldValuesResponse } from '@/storybook/msw/__story_mockdata__/fields';
import { queryRangeV5ScalarTableResponse } from '@/storybook/msw/__story_mockdata__/queryRange';
import {
attributeValuesResponse,
@@ -75,30 +77,34 @@ export const celeryTaskMocks = defineStoryMocks({
return [
rest.post('http://localhost/api/v3/query_range', queryRange),
rest.post('http://localhost/api/v4/query_range', queryRange),
rest.post(
'http://localhost/api/v5/query_range',
response.json(() =>
queryRangeV5ScalarTableResponse({
groupBy: ['worker'],
aggregations: ['A'],
rows: (
attributeValuesResponse('worker', '').data.stringAttributeValues ?? []
)
.slice(0, values.workers)
.map((worker) => [worker, 12]),
}),
),
),
rest.get(
'http://localhost/api/v3/autocomplete/attribute_values',
'http://localhost/api/v1/fields/values',
response.json((req) => {
const attributeKey = req.url.searchParams.get('attributeKey') ?? '';
const values_ = attributeValuesResponse(
attributeKey,
req.url.searchParams.get('searchText') ?? '',
const name = req.url.searchParams.get('name') ?? '';
const found =
attributeValuesResponse(
name,
req.url.searchParams.get('searchText') ?? '',
).data.stringAttributeValues ?? [];
return fieldValuesResponse(
name === 'worker' ? found.slice(0, values.workers) : found,
);
if (attributeKey !== 'worker') {
return values_;
}
return {
...values_,
data: {
...values_.data,
stringAttributeValues: (values_.data.stringAttributeValues ?? []).slice(
0,
values.workers,
),
},
};
}),
),
];

View File

@@ -13,6 +13,7 @@ import {
toggleControl,
} from '@/storybook/controls/controls';
import { defineStoryMocks } from '@/storybook/controls/defineStoryMocks';
import { fieldValuesResponse } from '@/storybook/msw/__story_mockdata__/fields';
import {
attributeValuesResponse,
@@ -91,11 +92,13 @@ export const queueOverviewMocks = defineStoryMocks({
rest.post('http://localhost/api/v4/query_range', queryRange),
rest.get(
'http://localhost/api/v3/autocomplete/attribute_values',
'http://localhost/api/v1/fields/values',
response.json((req) =>
attributeValuesResponse(
req.url.searchParams.get('attributeKey') ?? '',
req.url.searchParams.get('searchText') ?? '',
fieldValuesResponse(
attributeValuesResponse(
req.url.searchParams.get('name') ?? '',
req.url.searchParams.get('searchText') ?? '',
).data.stringAttributeValues ?? [],
),
),
),

View File

@@ -82,15 +82,15 @@ const CELERY_TASKS = [
const CELERY_WORKERS = ['worker-a', 'worker-b', 'worker-c'];
/**
* Values per autocomplete attribute key. The kafka config selects and both
* celery filter rows read the same v3 endpoint, so one map answers for all of
* Values per attribute key. The kafka config selects read the v3 endpoint and
* the celery filter rows read `/fields/values`, so one map answers for all of
* them; a key nobody seeded answers empty rather than 501.
*/
const ATTRIBUTE_VALUES: Record<string, string[]> = {
group: CONSUMER_GROUPS,
topic: TOPICS,
partition: PARTITIONS,
serviceName: KAFKA_SERVICES,
'service.name': KAFKA_SERVICES,
name: [
'order-events send',
'order-events process',

View File

@@ -3,6 +3,7 @@ import { Button, Form, Space, Tooltip } from 'antd';
import { Dropdown, type DropdownItemType } from '@signozhq/ui/dropdown';
import { Divider } from '@signozhq/ui/divider';
import { Switch } from '@signozhq/ui/switch';
import { TelemetrytypesFieldContextDTO } from 'api/generated/services/sigNoz.schemas';
import cx from 'classnames';
import { FilterSelect } from 'components/CeleryOverview/CeleryOverviewConfigOptions/CeleryOverviewConfigOptions';
import { QueryParams } from 'constants/query';
@@ -149,7 +150,8 @@ function FunnelStep({
<FilterSelect
placeholder="Select Service"
queryParam={QueryParams.service}
filterType="serviceName"
filterType="service.name"
fieldContext={TelemetrytypesFieldContextDTO.resource}
shouldSetQueryParams={false}
values={stepData.service_name}
isMultiple={false}
@@ -169,6 +171,7 @@ function FunnelStep({
placeholder="Select Span name"
queryParam={QueryParams.spanName}
filterType="name"
fieldContext={TelemetrytypesFieldContextDTO.span}
shouldSetQueryParams={false}
values={stepData.span_name}
isMultiple={false}

View File

@@ -3,15 +3,19 @@
* Do not hand-edit: regenerate instead.
*/
import {
TelemetrytypesFieldContextDTO,
TelemetrytypesSignalDTO,
} from 'api/generated/services/sigNoz.schemas';
import ROUTES from 'constants/routes';
import { rest } from 'msw';
import { choiceControl, countControl } from '@/storybook/controls/controls';
import { defineStoryMocks } from '@/storybook/controls/defineStoryMocks';
import {
attributeKeysResponse,
attributeValuesResponse,
} from '@/storybook/msw/__story_mockdata__/attributes';
fieldKeysResponse,
fieldValuesResponse,
} from '@/storybook/msw/__story_mockdata__/fields';
import {
FUNNEL_ID,
@@ -41,13 +45,9 @@ const CONVERSION: Record<DropOff, number> = {
const ENTERED = 24_000;
const STEP_FILTER_KEYS = [
'service.name',
'name',
'http.status_code',
'deployment.environment',
'hasError',
];
const STEP_RESOURCE_KEYS = ['service.name', 'deployment.environment'];
const STEP_ATTRIBUTE_KEYS = ['name', 'http.status_code', 'hasError'];
const STEP_FILTER_VALUES: Record<string, string[]> = {
'service.name': ['frontend', 'checkout', 'payment', 'shipping'],
@@ -115,20 +115,44 @@ export const tracesFunnelDetailsMocks = defineStoryMocks({
'http://localhost/api/v1/trace-funnels/analytics/error-traces',
response.json(() => funnelErrorTracesResponse(values.traces)),
),
// The `Where` box on every step is the trace query builder, which reads
// its suggestions as soon as the step renders.
// The `Where` box on every step reads its suggestions as soon as the step
// renders, and the service and span name selects read `service.name` and
// `name` from the same values endpoint.
rest.get(
'http://localhost/api/v3/autocomplete/attribute_keys',
response.json(() => attributeKeysResponse(STEP_FILTER_KEYS)),
'http://localhost/api/v1/fields/keys',
response.json(() => {
const signal = TelemetrytypesSignalDTO.traces;
const resource = fieldKeysResponse(STEP_RESOURCE_KEYS, {
signal,
fieldContext: TelemetrytypesFieldContextDTO.resource,
});
const attribute = fieldKeysResponse(STEP_ATTRIBUTE_KEYS, {
signal,
fieldContext: TelemetrytypesFieldContextDTO.attribute,
});
return {
...resource,
data: {
...resource.data,
keys: { ...resource.data.keys, ...attribute.data.keys },
},
};
}),
),
rest.get(
'http://localhost/api/v3/autocomplete/attribute_values',
response.json((req) =>
attributeValuesResponse(
STEP_FILTER_VALUES[req.url.searchParams.get('attributeKey') ?? ''] ?? [],
req.url.searchParams.get('searchText') ?? '',
),
),
'http://localhost/api/v1/fields/values',
response.json((req) => {
const searchText = (
req.url.searchParams.get('searchText') ?? ''
).toLowerCase();
return fieldValuesResponse(
(STEP_FILTER_VALUES[req.url.searchParams.get('name') ?? ''] ?? []).filter(
(value) => value.toLowerCase().includes(searchText),
),
);
}),
),
];
},

View File

@@ -53,6 +53,7 @@ export type FieldContext =
| 'scope'
| 'attribute'
| 'event'
| 'body'
| '';
export type FieldDataType =

View File

@@ -1,4 +1,6 @@
import { buildAbsolutePath } from '../app';
import { SIGNOZ_ADMIN_EMAIL } from 'constants/app';
import { buildAbsolutePath, isSignozAdminEmail } from '../app';
// buildAbsolutePath reads getCurrentLocation().pathname (basename-relative) rather than
// window.location.pathname, so we mock lib/router/navigation instead of utils/getLocation.
@@ -122,3 +124,13 @@ describe('buildAbsolutePath', () => {
});
});
});
describe('isSignozAdminEmail', () => {
it('matches the SigNoz admin email', () => {
expect(isSignozAdminEmail(SIGNOZ_ADMIN_EMAIL)).toBe(true);
});
it.each(['jon@winterfell.dev', '', undefined])('rejects %p', (email) => {
expect(isSignozAdminEmail(email)).toBe(false);
});
});

View File

@@ -0,0 +1,76 @@
import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
import {
attributeTypeToFieldContext,
toLegacyLogsFilter,
} from '../fieldContext';
const item = (type: string): TagFilter['items'][number] => ({
id: type,
key: { key: 'k', dataType: DataTypes.String, type },
op: '=',
value: 'v',
});
describe('toLegacyLogsFilter', () => {
it('sends attribute keys as tag and log fields as top-level fields', () => {
const filter: TagFilter = {
op: 'AND',
items: [
item('attribute'),
item('resource'),
item('scope'),
item('log'),
item('body'),
item('tag'),
item(''),
],
};
expect(
toLegacyLogsFilter(filter).items.map((filterItem) => filterItem.key?.type),
).toStrictEqual(['tag', 'resource', 'scope', '', '', 'tag', '']);
});
it('sends the scope name and version as top-level fields only from the scope context', () => {
const filter: TagFilter = {
op: 'AND',
items: [
['scope_name', 'scope'],
['scope_version', 'scope'],
['scope.attr', 'scope'],
['scope_name', 'attribute'],
['scope_name', 'tag'],
['scope_version', 'resource'],
].map(([key, type]) => ({
id: `${key}-${type}`,
key: { key, dataType: DataTypes.String, type },
op: '=',
value: 'v',
})),
};
expect(
toLegacyLogsFilter(filter).items.map((filterItem) => filterItem.key?.type),
).toStrictEqual(['', '', 'scope', 'tag', 'tag', 'resource']);
});
});
describe('attributeTypeToFieldContext', () => {
it('maps legacy tag to attribute and passes v5 contexts through', () => {
expect(
['tag', 'attribute', 'resource', 'scope', 'span', 'log', ''].map(
attributeTypeToFieldContext,
),
).toStrictEqual([
'attribute',
'attribute',
'resource',
'scope',
'span',
'log',
undefined,
]);
});
});

View File

@@ -1,4 +1,5 @@
import getLocalStorage from 'api/browser/localstorage/get';
import { SIGNOZ_ADMIN_EMAIL } from 'constants/app';
import { FeatureKeys } from 'constants/features';
import { SKIP_ONBOARDING } from 'constants/onboarding';
import dayjs from 'dayjs';
@@ -16,6 +17,9 @@ export function extractDomain(email: string): string {
return emailParts[1];
}
export const isSignozAdminEmail = (email?: string): boolean =>
email === SIGNOZ_ADMIN_EMAIL;
const stripVersionPrefix = (version: string): string =>
version?.replace(/^v/i, '') ?? '';

View File

@@ -0,0 +1,55 @@
import { TelemetrytypesFieldContextDTO } from 'api/generated/services/sigNoz.schemas';
import type { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
const FIELD_CONTEXT_TO_ATTRIBUTE_TYPE: Record<string, string> = {
[TelemetrytypesFieldContextDTO.attribute]: 'tag',
[TelemetrytypesFieldContextDTO.resource]: 'resource',
};
const ATTRIBUTE_TYPE_TO_FIELD_CONTEXT: Record<
string,
TelemetrytypesFieldContextDTO
> = {
tag: TelemetrytypesFieldContextDTO.attribute,
attribute: TelemetrytypesFieldContextDTO.attribute,
resource: TelemetrytypesFieldContextDTO.resource,
scope: TelemetrytypesFieldContextDTO.scope,
span: TelemetrytypesFieldContextDTO.span,
log: TelemetrytypesFieldContextDTO.log,
};
// The legacy logs builders read `tag` as attributes and an empty type as a top-level field;
// any other type falls through to resources.
const LEGACY_LOGS_KEY_TYPE: Record<string, string> = {
[TelemetrytypesFieldContextDTO.attribute]: 'tag',
tag: 'tag',
[TelemetrytypesFieldContextDTO.resource]: 'resource',
[TelemetrytypesFieldContextDTO.scope]: 'scope',
};
// Top-level log columns that v5 files under the scope context.
const LEGACY_LOGS_TOP_LEVEL_SCOPE_FIELDS = ['scope_name', 'scope_version'];
export const fieldContextToAttributeType = (fieldContext?: string): string =>
(fieldContext && FIELD_CONTEXT_TO_ATTRIBUTE_TYPE[fieldContext]) || '';
export const attributeTypeToFieldContext = (
type?: string | null,
): TelemetrytypesFieldContextDTO | undefined =>
type ? ATTRIBUTE_TYPE_TO_FIELD_CONTEXT[type] : undefined;
export const toLegacyLogsFilter = (filter: TagFilter): TagFilter =>
filter && {
...filter,
items: (filter.items ?? []).map((item) => ({
...item,
key: item.key && {
...item.key,
type:
item.key.type === TelemetrytypesFieldContextDTO.scope &&
LEGACY_LOGS_TOP_LEVEL_SCOPE_FIELDS.includes(item.key.key)
? ''
: (LEGACY_LOGS_KEY_TYPE[item.key.type ?? ''] ?? ''),
},
})),
};

View File

@@ -0,0 +1,21 @@
import { TelemetrytypesTelemetryFieldValuesDTO } from 'api/generated/services/sigNoz.schemas';
import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
// Numbers and bools stay raw so tags keep their value type.
export const getValuesForDataType = (
values: TelemetrytypesTelemetryFieldValuesDTO | undefined,
dataType: DataTypes | undefined,
): string[] => {
switch (dataType) {
case DataTypes.Int64:
case DataTypes.Float64:
case DataTypes.ArrayInt64:
case DataTypes.ArrayFloat64:
return (values?.numberValues ?? []) as unknown as string[];
case DataTypes.bool:
case DataTypes.ArrayBool:
return (values?.boolValues ?? []) as unknown as string[];
default:
return values?.stringValues ?? [];
}
};

View File

@@ -307,28 +307,6 @@ func (provider *provider) addRulerRoutes(router *mux.Router) error {
return err
}
if err := router.Handle("/api/v2/rules/{id}/disable", handler.New(
provider.authzMiddleware.CheckResources(provider.rulerHandler.DisableRuleByID, authtypes.SigNozAdminRoleName, authtypes.SigNozEditorRoleName),
handler.OpenAPIDef{
ID: "DisableRuleByID",
Tags: []string{"rules"},
Summary: "Disable alert rule",
Description: "This endpoint disables an alert rule by ID without validating its stored definition, so a rule that no longer passes validation can still be stopped. Enabling goes through the patch endpoint, which validates the whole rule.",
SuccessStatusCode: http.StatusNoContent,
ErrorStatusCodes: []int{http.StatusBadRequest, http.StatusNotFound},
SecuritySchemes: newScopedSecuritySchemes([]string{coretypes.ResourceMetaResourceRule.Scope(coretypes.VerbUpdate)}),
},
handler.WithResourceDefs(handler.BasicResourceDef{
Resource: coretypes.ResourceMetaResourceRule,
Verb: coretypes.VerbUpdate,
Category: coretypes.ActionCategoryConfigurationChange,
ID: coretypes.PathParam("id"),
Selector: coretypes.IDSelector,
}),
)).Methods(http.MethodPost).GetError(); err != nil {
return err
}
if err := router.Handle("/api/v2/rules/test", handler.New(
provider.authzMiddleware.CheckResources(provider.rulerHandler.TestRule, authtypes.SigNozAdminRoleName, authtypes.SigNozEditorRoleName),
handler.OpenAPIDef{

View File

@@ -1107,29 +1107,6 @@ func (m *Manager) PatchRule(ctx context.Context, ruleStr string, id valuer.UUID)
return &response, nil
}
func (m *Manager) DisableRule(ctx context.Context, id valuer.UUID) error {
claims, err := authtypes.ClaimsFromContext(ctx)
if err != nil {
return err
}
storedRule, err := m.ruleStore.GetStoredRule(ctx, valuer.MustNewUUID(claims.OrgID), id)
if err != nil {
return err
}
if err := storedRule.Disable(); err != nil {
return err
}
storedRule.UpdatedBy = claims.Email
storedRule.UpdatedAt = time.Now()
return m.ruleStore.EditRule(ctx, storedRule, func(context.Context) error {
m.deleteTask(prepareTaskName(id.StringValue()))
return nil
})
}
// TestNotification prepares a dummy rule for given rule parameters and
// sends a test notification. returns alert count and error (if any)
func (m *Manager) TestNotification(ctx context.Context, orgID valuer.UUID, ruleStr string) (int, error) {

View File

@@ -10,7 +10,6 @@ type Handler interface {
UpdateRuleByID(http.ResponseWriter, *http.Request)
DeleteRuleByID(http.ResponseWriter, *http.Request)
PatchRuleByID(http.ResponseWriter, *http.Request)
DisableRuleByID(http.ResponseWriter, *http.Request)
TestRule(http.ResponseWriter, *http.Request)
ListRuleViews(http.ResponseWriter, *http.Request)

View File

@@ -44,9 +44,6 @@ type Ruler interface {
// TODO: same as CreateRule — accept PostableRule instead of raw string.
PatchRule(ctx context.Context, ruleStr string, id valuer.UUID) (*ruletypes.GettableRule, error)
// DisableRule stops the rule identified by id without decoding or validating its stored definition.
DisableRule(ctx context.Context, id valuer.UUID) error
// TestNotification fires a test alert for the rule defined in ruleStr.
// TODO: same as CreateRule — accept PostableRule instead of raw string.
TestNotification(ctx context.Context, orgID valuer.UUID, ruleStr string) (int, error)

View File

@@ -177,24 +177,6 @@ func (handler *handler) PatchRuleByID(rw http.ResponseWriter, req *http.Request)
render.Success(rw, http.StatusOK, ruletypes.NewRule(rule))
}
func (handler *handler) DisableRuleByID(rw http.ResponseWriter, req *http.Request) {
ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
defer cancel()
id, err := valuer.NewUUID(mux.Vars(req)["id"])
if err != nil {
render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid"))
return
}
if err := handler.ruler.DisableRule(ctx, id); err != nil {
render.Error(rw, err)
return
}
render.Success(rw, http.StatusNoContent, nil)
}
func (handler *handler) TestRule(rw http.ResponseWriter, req *http.Request) {
ctx, cancel := context.WithTimeout(req.Context(), 1*time.Minute)
defer cancel()

View File

@@ -165,10 +165,6 @@ func (provider *provider) PatchRule(ctx context.Context, ruleStr string, id valu
return provider.manager.PatchRule(ctx, ruleStr, id)
}
func (provider *provider) DisableRule(ctx context.Context, id valuer.UUID) error {
return provider.manager.DisableRule(ctx, id)
}
func (provider *provider) TestNotification(ctx context.Context, orgID valuer.UUID, ruleStr string) (int, error) {
return provider.manager.TestNotification(ctx, orgID, ruleStr)
}

View File

@@ -5,7 +5,6 @@ import (
"encoding/json"
"strings"
"github.com/SigNoz/signoz/pkg/errors"
"github.com/SigNoz/signoz/pkg/types"
"github.com/SigNoz/signoz/pkg/valuer"
"github.com/uptrace/bun"
@@ -58,22 +57,6 @@ func (rule *StorableRule) ToPostableRuleForCloning() (*PostableRule, error) {
return postable, nil
}
func (rule *StorableRule) Disable() error {
// only the disabled key is touched, so a rule whose data no longer decodes into PostableRule can still be disabled
data := map[string]json.RawMessage{}
if err := json.Unmarshal([]byte(rule.Data), &data); err != nil {
return errors.WrapInternalf(err, errors.CodeInternal, "stored rule data is not a json object")
}
data["disabled"] = json.RawMessage("true")
encoded, err := json.Marshal(data)
if err != nil {
return err
}
rule.Data = string(encoded)
return nil
}
// RuleAlert represents an alert associated with a rule, used when filtering by metric name.
type RuleAlert struct {
AlertName string

46
tests/fixtures/fileauditor.py vendored Normal file
View File

@@ -0,0 +1,46 @@
import json
import time
import docker
from fixtures import types
AUDIT_FILE_PATH = "/tmp/audit.log"
def list_audit_events(signoz: types.SigNoz) -> list[dict]:
"""Each line of the audit file is one OTLP JSON batch of events; this flattens all batches into events."""
exit_code, output = docker.from_env().containers.get(signoz.self.id).exec_run(["cat", AUDIT_FILE_PATH])
assert exit_code == 0, output.decode()
events = []
for line in output.decode().splitlines():
for resource_logs in json.loads(line)["resourceLogs"]:
resource = {attribute["key"]: attribute["value"]["stringValue"] for attribute in resource_logs["resource"]["attributes"]}
for scope_logs in resource_logs["scopeLogs"]:
for log_record in scope_logs["logRecords"]:
events.append(
{
"event_name": log_record["eventName"],
"severity_text": log_record["severityText"],
"body": log_record["body"]["stringValue"],
"scope_name": scope_logs["scope"]["name"],
"resource": resource,
"attributes": {attribute["key"]: int(attribute["value"]["intValue"]) if "intValue" in attribute["value"] else attribute["value"]["stringValue"] for attribute in log_record["attributes"]},
}
)
return events
def wait_for_audit_event(signoz: types.SigNoz, event_name: str, resource_id: str, target_id: str | None = None, wait_seconds: int = 10) -> dict:
deadline = time.time() + wait_seconds
events = []
while time.time() < deadline:
events = list_audit_events(signoz)
matched = [event for event in events if event["event_name"] == event_name and event["resource"].get("signoz.resource.id") == resource_id and (target_id is None or event["attributes"].get("signoz.resource.target.id") == target_id)]
if len(matched) > 0:
return matched[0]
time.sleep(0.5)
raise AssertionError(f"No {event_name} audit event for resource {resource_id} (target {target_id}) within {wait_seconds}s, events: {events}")

View File

@@ -0,0 +1,151 @@
import uuid
from collections.abc import Callable
from http import HTTPStatus
import requests
from fixtures import types
from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD, find_user_by_email
from fixtures.fileauditor import wait_for_audit_event
from fixtures.savedview import SAVED_VIEW_BASE, create_saved_view
from fixtures.serviceaccount import SERVICE_ACCOUNT_BASE, create_service_account, create_service_account_with_key, delete_service_account, get_first_key_id
def test_create_saved_view_writes_create_event(
signoz: types.SigNoz,
apply_license: types.Operation, # pylint: disable=unused-argument
get_token: Callable[[str, str], str],
) -> None:
token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
admin = find_user_by_email(signoz, token, USER_ADMIN_EMAIL)
view_id = create_saved_view(signoz, token, f"fileauditor-{uuid.uuid4().hex[:8]}")
event = wait_for_audit_event(signoz, "signoz.audit.create", view_id)
assert event["severity_text"] == "INFO"
assert event["scope_name"] == "signoz.audit"
assert event["resource"]["service.name"] == "signoz"
assert event["resource"]["signoz.resource.kind"] == "saved-view"
assert event["attributes"]["signoz.audit.verb"] == "create"
assert event["attributes"]["signoz.audit.outcome"] == "success"
assert event["attributes"]["signoz.principal.id"] == admin["id"]
assert event["attributes"]["signoz.principal.email"] == USER_ADMIN_EMAIL
assert event["attributes"]["signoz.organization.id"] == admin["orgId"]
assert event["attributes"]["http.request.method"] == "POST"
assert event["attributes"]["http.route"] == "/api/v2/saved_views"
assert event["attributes"]["http.response.status_code"] == HTTPStatus.CREATED
def test_update_service_account_writes_update_event(
signoz: types.SigNoz,
apply_license: types.Operation, # pylint: disable=unused-argument
get_token: Callable[[str, str], str],
) -> None:
token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
service_account_id = create_service_account(signoz, token, f"fileauditor-{uuid.uuid4().hex[:8]}")
response = requests.put(
signoz.self.host_configs["8080"].get(f"{SERVICE_ACCOUNT_BASE}/{service_account_id}"),
json={"name": f"fileauditor-{uuid.uuid4().hex[:8]}"},
headers={"Authorization": f"Bearer {token}"},
timeout=5,
)
assert response.status_code == HTTPStatus.NO_CONTENT, response.text
event = wait_for_audit_event(signoz, "signoz.audit.update", service_account_id)
assert event["resource"]["signoz.resource.kind"] == "serviceaccount"
assert event["attributes"]["signoz.audit.verb"] == "update"
assert event["attributes"]["signoz.audit.outcome"] == "success"
assert event["attributes"]["http.route"] == "/api/v1/service_accounts/{id}"
assert event["attributes"]["http.response.status_code"] == HTTPStatus.NO_CONTENT
def test_delete_service_account_writes_delete_event(
signoz: types.SigNoz,
apply_license: types.Operation, # pylint: disable=unused-argument
get_token: Callable[[str, str], str],
) -> None:
token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
service_account_id = create_service_account(signoz, token, f"fileauditor-{uuid.uuid4().hex[:8]}")
delete_service_account(signoz, token, service_account_id)
event = wait_for_audit_event(signoz, "signoz.audit.delete", service_account_id)
assert event["resource"]["signoz.resource.kind"] == "serviceaccount"
assert event["attributes"]["signoz.audit.verb"] == "delete"
assert event["attributes"]["signoz.audit.outcome"] == "success"
assert event["attributes"]["http.route"] == "/api/v1/service_accounts/{id}"
assert event["attributes"]["http.response.status_code"] == HTTPStatus.NO_CONTENT
def test_create_service_account_key_writes_attach_event(
signoz: types.SigNoz,
apply_license: types.Operation, # pylint: disable=unused-argument
get_token: Callable[[str, str], str],
) -> None:
token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
service_account_id = create_service_account(signoz, token, f"fileauditor-{uuid.uuid4().hex[:8]}")
response = requests.post(
signoz.self.host_configs["8080"].get(f"{SERVICE_ACCOUNT_BASE}/{service_account_id}/keys"),
json={"name": "fileauditor", "expiresAt": 0},
headers={"Authorization": f"Bearer {token}"},
timeout=5,
)
assert response.status_code == HTTPStatus.CREATED, response.text
key_id = response.json()["data"]["id"]
event = wait_for_audit_event(signoz, "signoz.audit.attach", service_account_id, target_id=key_id)
assert event["resource"]["signoz.resource.kind"] == "serviceaccount"
assert event["attributes"]["signoz.resource.target.kind"] == "factor-api-key"
assert event["attributes"]["signoz.audit.verb"] == "attach"
assert event["attributes"]["signoz.audit.outcome"] == "success"
assert event["attributes"]["http.route"] == "/api/v1/service_accounts/{id}/keys"
assert event["attributes"]["http.response.status_code"] == HTTPStatus.CREATED
def test_revoke_service_account_key_writes_detach_event(
signoz: types.SigNoz,
apply_license: types.Operation, # pylint: disable=unused-argument
get_token: Callable[[str, str], str],
) -> None:
token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
service_account_id, _ = create_service_account_with_key(signoz, token, f"fileauditor-{uuid.uuid4().hex[:8]}")
key_id = get_first_key_id(signoz, token, service_account_id)
response = requests.delete(
signoz.self.host_configs["8080"].get(f"{SERVICE_ACCOUNT_BASE}/{service_account_id}/keys/{key_id}"),
headers={"Authorization": f"Bearer {token}"},
timeout=5,
)
assert response.status_code == HTTPStatus.NO_CONTENT, response.text
event = wait_for_audit_event(signoz, "signoz.audit.detach", service_account_id, target_id=key_id)
assert event["resource"]["signoz.resource.kind"] == "serviceaccount"
assert event["attributes"]["signoz.resource.target.kind"] == "factor-api-key"
assert event["attributes"]["signoz.audit.verb"] == "detach"
assert event["attributes"]["signoz.audit.outcome"] == "success"
assert event["attributes"]["http.route"] == "/api/v1/service_accounts/{id}/keys/{fid}"
assert event["attributes"]["http.response.status_code"] == HTTPStatus.NO_CONTENT
def test_delete_missing_saved_view_writes_failure_event(
signoz: types.SigNoz,
apply_license: types.Operation, # pylint: disable=unused-argument
get_token: Callable[[str, str], str],
) -> None:
token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
missing_view_id = str(uuid.uuid4())
response = requests.delete(
signoz.self.host_configs["8080"].get(f"{SAVED_VIEW_BASE}/{missing_view_id}"),
headers={"Authorization": f"Bearer {token}"},
timeout=5,
)
assert response.status_code == HTTPStatus.NOT_FOUND, response.text
event = wait_for_audit_event(signoz, "signoz.audit.delete", missing_view_id)
assert event["severity_text"] == "ERROR"
assert event["attributes"]["signoz.audit.outcome"] == "failure"
assert event["attributes"]["exception.type"] == "not-found"
assert event["attributes"]["http.response.status_code"] == HTTPStatus.NOT_FOUND

View File

@@ -0,0 +1,32 @@
import pytest
from testcontainers.core.container import Network
from fixtures import types
from fixtures.fileauditor import AUDIT_FILE_PATH
from fixtures.signoz import create_signoz
@pytest.fixture(name="signoz", scope="package")
def signoz_fileauditor(
network: Network,
zeus: types.TestContainerDocker,
gateway: types.TestContainerDocker,
sqlstore: types.TestContainerSQL,
clickhouse: types.TestContainerClickhouse,
request: pytest.FixtureRequest,
pytestconfig: pytest.Config,
) -> types.SigNoz:
return create_signoz(
network=network,
zeus=zeus,
gateway=gateway,
sqlstore=sqlstore,
clickhouse=clickhouse,
request=request,
pytestconfig=pytestconfig,
cache_key="signoz-fileauditor",
env_overrides={
"SIGNOZ_AUDITOR_PROVIDER": "file",
"SIGNOZ_AUDITOR_FILE_PATH": AUDIT_FILE_PATH,
},
)

View File

@@ -508,7 +508,6 @@ def test_viewer_forbidden_on_rule_writes(
("patch", f"{V2_RULES_URL}/{target_id}", {"description": "viewer patch"}),
("delete", f"{V2_RULES_URL}/{target_id}", None),
("post", f"{V2_RULES_URL}/{target_id}/clone", None),
("post", f"{V2_RULES_URL}/{target_id}/disable", None),
("post", f"{V2_RULES_URL}/test", body),
):
response = getattr(requests, method)(

View File

@@ -1,74 +0,0 @@
import json
import uuid
from collections.abc import Callable
from http import HTTPStatus
import requests
from sqlalchemy import sql
from fixtures.alerts import get_rule
from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
from fixtures.types import Operation, SigNoz
BASE_URL = "/api/v2/rules"
ENABLED_RULE_PATH = "ruler/test_scenarios/threshold_above_at_least_once/rule.json"
def test_disable_rule(
signoz: SigNoz,
create_alert_rule_with_channel: Callable[[str], str],
get_token: Callable[[str, str], str],
):
token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
rule_id = create_alert_rule_with_channel(ENABLED_RULE_PATH)
response = requests.post(signoz.self.host_configs["8080"].get(f"{BASE_URL}/{rule_id}/disable"), headers={"Authorization": f"Bearer {token}"}, timeout=5)
assert response.status_code == HTTPStatus.NO_CONTENT, response.text
rule = get_rule(signoz, token, rule_id)
assert rule["disabled"] is True
assert rule["state"] == "disabled"
assert rule["updatedBy"] == USER_ADMIN_EMAIL
# disabling an already disabled rule succeeds
response = requests.post(signoz.self.host_configs["8080"].get(f"{BASE_URL}/{rule_id}/disable"), headers={"Authorization": f"Bearer {token}"}, timeout=5)
assert response.status_code == HTTPStatus.NO_CONTENT, response.text
def test_disable_rule_with_unknown_id(
signoz: SigNoz,
create_user_admin: Operation, # pylint: disable=unused-argument
get_token: Callable[[str, str], str],
):
token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
response = requests.post(signoz.self.host_configs["8080"].get(f"{BASE_URL}/{uuid.uuid4()}/disable"), headers={"Authorization": f"Bearer {token}"}, timeout=5)
assert response.status_code == HTTPStatus.NOT_FOUND, response.text
response = requests.post(signoz.self.host_configs["8080"].get(f"{BASE_URL}/not-a-uuid/disable"), headers={"Authorization": f"Bearer {token}"}, timeout=5)
assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
def test_disable_rule_with_undecodable_stored_data(
signoz: SigNoz,
create_alert_rule_with_channel: Callable[[str], str],
get_token: Callable[[str, str], str],
):
token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
rule_id = create_alert_rule_with_channel(ENABLED_RULE_PATH)
with signoz.sqlstore.conn.begin() as conn:
conn.execute(
sql.text("UPDATE rule SET data = :data WHERE id = :id"),
{"data": json.dumps({"alert": "undecodable", "condition": "not an object", "disabled": False}), "id": rule_id},
)
response = requests.post(signoz.self.host_configs["8080"].get(f"{BASE_URL}/{rule_id}/disable"), headers={"Authorization": f"Bearer {token}"}, timeout=5)
assert response.status_code == HTTPStatus.NO_CONTENT, response.text
# every key other than disabled stays as stored
with signoz.sqlstore.conn.connect() as conn:
stored = conn.execute(sql.text("SELECT data FROM rule WHERE id = :id"), {"id": rule_id}).fetchone()
assert stored is not None
assert json.loads(stored[0]) == {"alert": "undecodable", "condition": "not an object", "disabled": True}