fix: correct check for flux interval in tracedetail apis

* refactor(alertmanager): move API handlers to signozapiserver

Extract Handler interface in pkg/alertmanager/handler.go and move
the implementation from api.go to signozalertmanager/handler.go.

Register all alertmanager routes (channels, route policies, alerts)
in signozapiserver via handler.New() with OpenAPIDef. Remove
AlertmanagerAPI injection from http_handler.go.

This enables future AuditDef instrumentation on these routes.

* fix(review): rename param, add /api/v1/channels/test endpoint

- Rename `am` to `alertmanagerService` in NewHandlers
- Add /api/v1/channels/test as the canonical test endpoint
- Mark /api/v1/testChannel as deprecated
- Regenerate OpenAPI spec

* fix(review): use camelCase for channel orgId json tag

* fix(review): remove section comments from alertmanager routes

* fix(review): use routepolicies tag without hyphen

* chore: regenerate frontend API clients for alertmanager routes

* fix: add required/nullable/enum tags to alertmanager OpenAPI types

- PostableRoutePolicy: mark expression, name, channels as required
- GettableRoutePolicy: change CreatedAt/UpdatedAt from pointer to value
- Channel: mark name, type, data, orgId as required
- ExpressionKind: add Enum() for rule/policy values
- Regenerate OpenAPI spec and frontend clients

* fix: use typed response for GetAlerts endpoint

* fix: add Receiver request type to channel mutation endpoints

CreateChannel, UpdateChannelByID, TestChannel, and TestChannelDeprecated
all read req.Body as a Receiver config. The OpenAPIDef must declare
the request type so the generated SDK includes the body parameter.

* fix: change CreateChannel access from EditAccess to AdminAccess

Aligns CreateChannel endpoint with the rest of the channel mutation
endpoints (update/delete) which all require admin access. This is
consistent with the frontend where notifications are not accessible
to editors.

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

@@ -6,7 +6,6 @@ import (
 
 	"github.com/SigNoz/signoz/ee/licensing/httplicensing"
 	"github.com/SigNoz/signoz/ee/query-service/usage"
-	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	baseapp "github.com/SigNoz/signoz/pkg/query-service/app"
@@ -49,7 +48,6 @@ func NewAPIHandler(opts APIHandlerOptions, signoz *signoz.SigNoz, config signoz.
 		CloudIntegrationsController:   opts.CloudIntegrationsController,
 		LogsParsingPipelineController: opts.LogsParsingPipelineController,
 		FluxInterval:                  opts.FluxInterval,
-		AlertmanagerAPI:               alertmanager.NewAPI(signoz.Alertmanager),
 		LicensingAPI:                  httplicensing.NewLicensingAPI(signoz.Licensing),
 		Signoz:                        signoz,
 		QueryParserAPI:                queryparser.NewAPI(signoz.Instrumentation.ToProviderSettings(), signoz.QueryParser),

frontend/src/api/generated/services/alerts/index.ts

@@ -0,0 +1,97 @@
+/**
+ * ! Do not edit manually
+ * * The file has been auto-generated using Orval for SigNoz
+ * * regenerate with 'yarn generate:api'
+ * SigNoz
+ */
+import type {
+	InvalidateOptions,
+	QueryClient,
+	QueryFunction,
+	QueryKey,
+	UseQueryOptions,
+	UseQueryResult,
+} from 'react-query';
+import { useQuery } from 'react-query';
+
+import type { ErrorType } from '../../../generatedAPIInstance';
+import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
+import type { GetAlerts200, RenderErrorResponseDTO } from '../sigNoz.schemas';
+
+/**
+ * This endpoint returns alerts for the organization
+ * @summary Get alerts
+ */
+export const getAlerts = (signal?: AbortSignal) => {
+	return GeneratedAPIInstance<GetAlerts200>({
+		url: `/api/v1/alerts`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getGetAlertsQueryKey = () => {
+	return [`/api/v1/alerts`] as const;
+};
+
+export const getGetAlertsQueryOptions = <
+	TData = Awaited<ReturnType<typeof getAlerts>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(options?: {
+	query?: UseQueryOptions<Awaited<ReturnType<typeof getAlerts>>, TError, TData>;
+}) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey = queryOptions?.queryKey ?? getGetAlertsQueryKey();
+
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof getAlerts>>> = ({
+		signal,
+	}) => getAlerts(signal);
+
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+		Awaited<ReturnType<typeof getAlerts>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type GetAlertsQueryResult = NonNullable<
+	Awaited<ReturnType<typeof getAlerts>>
+>;
+export type GetAlertsQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Get alerts
+ */
+
+export function useGetAlerts<
+	TData = Awaited<ReturnType<typeof getAlerts>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(options?: {
+	query?: UseQueryOptions<Awaited<ReturnType<typeof getAlerts>>, TError, TData>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getGetAlertsQueryOptions(options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary Get alerts
+ */
+export const invalidateGetAlerts = async (
+	queryClient: QueryClient,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getGetAlertsQueryKey() },
+		options,
+	);
+
+	return queryClient;
+};

frontend/src/api/generated/services/channels/index.ts

@@ -0,0 +1,646 @@
+/**
+ * ! Do not edit manually
+ * * The file has been auto-generated using Orval for SigNoz
+ * * regenerate with 'yarn generate:api'
+ * SigNoz
+ */
+import type {
+	InvalidateOptions,
+	MutationFunction,
+	QueryClient,
+	QueryFunction,
+	QueryKey,
+	UseMutationOptions,
+	UseMutationResult,
+	UseQueryOptions,
+	UseQueryResult,
+} from 'react-query';
+import { useMutation, useQuery } from 'react-query';
+
+import type { BodyType, ErrorType } from '../../../generatedAPIInstance';
+import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
+import type {
+	ConfigReceiverDTO,
+	CreateChannel201,
+	DeleteChannelByIDPathParameters,
+	GetChannelByID200,
+	GetChannelByIDPathParameters,
+	ListChannels200,
+	RenderErrorResponseDTO,
+	UpdateChannelByIDPathParameters,
+} from '../sigNoz.schemas';
+
+/**
+ * This endpoint lists all notification channels for the organization
+ * @summary List notification channels
+ */
+export const listChannels = (signal?: AbortSignal) => {
+	return GeneratedAPIInstance<ListChannels200>({
+		url: `/api/v1/channels`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getListChannelsQueryKey = () => {
+	return [`/api/v1/channels`] as const;
+};
+
+export const getListChannelsQueryOptions = <
+	TData = Awaited<ReturnType<typeof listChannels>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(options?: {
+	query?: UseQueryOptions<
+		Awaited<ReturnType<typeof listChannels>>,
+		TError,
+		TData
+	>;
+}) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey = queryOptions?.queryKey ?? getListChannelsQueryKey();
+
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof listChannels>>> = ({
+		signal,
+	}) => listChannels(signal);
+
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+		Awaited<ReturnType<typeof listChannels>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type ListChannelsQueryResult = NonNullable<
+	Awaited<ReturnType<typeof listChannels>>
+>;
+export type ListChannelsQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary List notification channels
+ */
+
+export function useListChannels<
+	TData = Awaited<ReturnType<typeof listChannels>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(options?: {
+	query?: UseQueryOptions<
+		Awaited<ReturnType<typeof listChannels>>,
+		TError,
+		TData
+	>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getListChannelsQueryOptions(options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary List notification channels
+ */
+export const invalidateListChannels = async (
+	queryClient: QueryClient,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getListChannelsQueryKey() },
+		options,
+	);
+
+	return queryClient;
+};
+
+/**
+ * This endpoint creates a notification channel
+ * @summary Create notification channel
+ */
+export const createChannel = (
+	configReceiverDTO: BodyType<ConfigReceiverDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<CreateChannel201>({
+		url: `/api/v1/channels`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: configReceiverDTO,
+		signal,
+	});
+};
+
+export const getCreateChannelMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createChannel>>,
+		TError,
+		{ data: BodyType<ConfigReceiverDTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof createChannel>>,
+	TError,
+	{ data: BodyType<ConfigReceiverDTO> },
+	TContext
+> => {
+	const mutationKey = ['createChannel'];
+	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 createChannel>>,
+		{ data: BodyType<ConfigReceiverDTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return createChannel(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type CreateChannelMutationResult = NonNullable<
+	Awaited<ReturnType<typeof createChannel>>
+>;
+export type CreateChannelMutationBody = BodyType<ConfigReceiverDTO>;
+export type CreateChannelMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Create notification channel
+ */
+export const useCreateChannel = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createChannel>>,
+		TError,
+		{ data: BodyType<ConfigReceiverDTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof createChannel>>,
+	TError,
+	{ data: BodyType<ConfigReceiverDTO> },
+	TContext
+> => {
+	const mutationOptions = getCreateChannelMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint deletes a notification channel by ID
+ * @summary Delete notification channel
+ */
+export const deleteChannelByID = ({ id }: DeleteChannelByIDPathParameters) => {
+	return GeneratedAPIInstance<void>({
+		url: `/api/v1/channels/${id}`,
+		method: 'DELETE',
+	});
+};
+
+export const getDeleteChannelByIDMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof deleteChannelByID>>,
+		TError,
+		{ pathParams: DeleteChannelByIDPathParameters },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof deleteChannelByID>>,
+	TError,
+	{ pathParams: DeleteChannelByIDPathParameters },
+	TContext
+> => {
+	const mutationKey = ['deleteChannelByID'];
+	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 deleteChannelByID>>,
+		{ pathParams: DeleteChannelByIDPathParameters }
+	> = (props) => {
+		const { pathParams } = props ?? {};
+
+		return deleteChannelByID(pathParams);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type DeleteChannelByIDMutationResult = NonNullable<
+	Awaited<ReturnType<typeof deleteChannelByID>>
+>;
+
+export type DeleteChannelByIDMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Delete notification channel
+ */
+export const useDeleteChannelByID = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof deleteChannelByID>>,
+		TError,
+		{ pathParams: DeleteChannelByIDPathParameters },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof deleteChannelByID>>,
+	TError,
+	{ pathParams: DeleteChannelByIDPathParameters },
+	TContext
+> => {
+	const mutationOptions = getDeleteChannelByIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint returns a notification channel by ID
+ * @summary Get notification channel by ID
+ */
+export const getChannelByID = (
+	{ id }: GetChannelByIDPathParameters,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<GetChannelByID200>({
+		url: `/api/v1/channels/${id}`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getGetChannelByIDQueryKey = ({
+	id,
+}: GetChannelByIDPathParameters) => {
+	return [`/api/v1/channels/${id}`] as const;
+};
+
+export const getGetChannelByIDQueryOptions = <
+	TData = Awaited<ReturnType<typeof getChannelByID>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(
+	{ id }: GetChannelByIDPathParameters,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getChannelByID>>,
+			TError,
+			TData
+		>;
+	},
+) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey = queryOptions?.queryKey ?? getGetChannelByIDQueryKey({ id });
+
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof getChannelByID>>> = ({
+		signal,
+	}) => getChannelByID({ id }, signal);
+
+	return {
+		queryKey,
+		queryFn,
+		enabled: !!id,
+		...queryOptions,
+	} as UseQueryOptions<
+		Awaited<ReturnType<typeof getChannelByID>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type GetChannelByIDQueryResult = NonNullable<
+	Awaited<ReturnType<typeof getChannelByID>>
+>;
+export type GetChannelByIDQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Get notification channel by ID
+ */
+
+export function useGetChannelByID<
+	TData = Awaited<ReturnType<typeof getChannelByID>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(
+	{ id }: GetChannelByIDPathParameters,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getChannelByID>>,
+			TError,
+			TData
+		>;
+	},
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getGetChannelByIDQueryOptions({ id }, options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary Get notification channel by ID
+ */
+export const invalidateGetChannelByID = async (
+	queryClient: QueryClient,
+	{ id }: GetChannelByIDPathParameters,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getGetChannelByIDQueryKey({ id }) },
+		options,
+	);
+
+	return queryClient;
+};
+
+/**
+ * This endpoint updates a notification channel by ID
+ * @summary Update notification channel
+ */
+export const updateChannelByID = (
+	{ id }: UpdateChannelByIDPathParameters,
+	configReceiverDTO: BodyType<ConfigReceiverDTO>,
+) => {
+	return GeneratedAPIInstance<void>({
+		url: `/api/v1/channels/${id}`,
+		method: 'PUT',
+		headers: { 'Content-Type': 'application/json' },
+		data: configReceiverDTO,
+	});
+};
+
+export const getUpdateChannelByIDMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateChannelByID>>,
+		TError,
+		{
+			pathParams: UpdateChannelByIDPathParameters;
+			data: BodyType<ConfigReceiverDTO>;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof updateChannelByID>>,
+	TError,
+	{
+		pathParams: UpdateChannelByIDPathParameters;
+		data: BodyType<ConfigReceiverDTO>;
+	},
+	TContext
+> => {
+	const mutationKey = ['updateChannelByID'];
+	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 updateChannelByID>>,
+		{
+			pathParams: UpdateChannelByIDPathParameters;
+			data: BodyType<ConfigReceiverDTO>;
+		}
+	> = (props) => {
+		const { pathParams, data } = props ?? {};
+
+		return updateChannelByID(pathParams, data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type UpdateChannelByIDMutationResult = NonNullable<
+	Awaited<ReturnType<typeof updateChannelByID>>
+>;
+export type UpdateChannelByIDMutationBody = BodyType<ConfigReceiverDTO>;
+export type UpdateChannelByIDMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Update notification channel
+ */
+export const useUpdateChannelByID = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateChannelByID>>,
+		TError,
+		{
+			pathParams: UpdateChannelByIDPathParameters;
+			data: BodyType<ConfigReceiverDTO>;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof updateChannelByID>>,
+	TError,
+	{
+		pathParams: UpdateChannelByIDPathParameters;
+		data: BodyType<ConfigReceiverDTO>;
+	},
+	TContext
+> => {
+	const mutationOptions = getUpdateChannelByIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint tests a notification channel by sending a test notification
+ * @summary Test notification channel
+ */
+export const testChannel = (
+	configReceiverDTO: BodyType<ConfigReceiverDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<void>({
+		url: `/api/v1/channels/test`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: configReceiverDTO,
+		signal,
+	});
+};
+
+export const getTestChannelMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof testChannel>>,
+		TError,
+		{ data: BodyType<ConfigReceiverDTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof testChannel>>,
+	TError,
+	{ data: BodyType<ConfigReceiverDTO> },
+	TContext
+> => {
+	const mutationKey = ['testChannel'];
+	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 testChannel>>,
+		{ data: BodyType<ConfigReceiverDTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return testChannel(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type TestChannelMutationResult = NonNullable<
+	Awaited<ReturnType<typeof testChannel>>
+>;
+export type TestChannelMutationBody = BodyType<ConfigReceiverDTO>;
+export type TestChannelMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Test notification channel
+ */
+export const useTestChannel = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof testChannel>>,
+		TError,
+		{ data: BodyType<ConfigReceiverDTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof testChannel>>,
+	TError,
+	{ data: BodyType<ConfigReceiverDTO> },
+	TContext
+> => {
+	const mutationOptions = getTestChannelMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * Deprecated: use /api/v1/channels/test instead
+ * @deprecated
+ * @summary Test notification channel (deprecated)
+ */
+export const testChannelDeprecated = (
+	configReceiverDTO: BodyType<ConfigReceiverDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<void>({
+		url: `/api/v1/testChannel`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: configReceiverDTO,
+		signal,
+	});
+};
+
+export const getTestChannelDeprecatedMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof testChannelDeprecated>>,
+		TError,
+		{ data: BodyType<ConfigReceiverDTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof testChannelDeprecated>>,
+	TError,
+	{ data: BodyType<ConfigReceiverDTO> },
+	TContext
+> => {
+	const mutationKey = ['testChannelDeprecated'];
+	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 testChannelDeprecated>>,
+		{ data: BodyType<ConfigReceiverDTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return testChannelDeprecated(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type TestChannelDeprecatedMutationResult = NonNullable<
+	Awaited<ReturnType<typeof testChannelDeprecated>>
+>;
+export type TestChannelDeprecatedMutationBody = BodyType<ConfigReceiverDTO>;
+export type TestChannelDeprecatedMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @deprecated
+ * @summary Test notification channel (deprecated)
+ */
+export const useTestChannelDeprecated = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof testChannelDeprecated>>,
+		TError,
+		{ data: BodyType<ConfigReceiverDTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof testChannelDeprecated>>,
+	TError,
+	{ data: BodyType<ConfigReceiverDTO> },
+	TContext
+> => {
+	const mutationOptions = getTestChannelDeprecatedMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};

frontend/src/api/generated/services/infra-monitoring/index.ts

@@ -1,104 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'yarn generate:api'
- * SigNoz
- */
-import type {
-	MutationFunction,
-	UseMutationOptions,
-	UseMutationResult,
-} from 'react-query';
-import { useMutation } from 'react-query';
-
-import type { BodyType, ErrorType } from '../../../generatedAPIInstance';
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type {
-	HostsList200,
-	InframonitoringtypesHostsListRequestDTO,
-	RenderErrorResponseDTO,
-} from '../sigNoz.schemas';
-
-/**
- * Returns a paginated list of hosts with key infrastructure metrics: CPU usage (%), memory usage (%), I/O wait (%), disk usage (%), and 15-minute load average. Each host includes its current status (active/inactive based on metrics reported in the last 10 minutes) and metadata attributes (e.g., os.type). Supports filtering via a filter expression, filtering by host status, custom groupBy to aggregate hosts by any attribute, ordering by any of the five metrics, and pagination via offset/limit. The response type is 'list' for the default host.name grouping or 'grouped_list' for custom groupBy keys. Also reports missing required metrics and whether the requested time range falls before the data retention boundary.
- * @summary List Hosts for Infra Monitoring
- */
-export const hostsList = (
-	inframonitoringtypesHostsListRequestDTO: BodyType<InframonitoringtypesHostsListRequestDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<HostsList200>({
-		url: `/api/v2/infra_monitoring/hosts`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: inframonitoringtypesHostsListRequestDTO,
-		signal,
-	});
-};
-
-export const getHostsListMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof hostsList>>,
-		TError,
-		{ data: BodyType<InframonitoringtypesHostsListRequestDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof hostsList>>,
-	TError,
-	{ data: BodyType<InframonitoringtypesHostsListRequestDTO> },
-	TContext
-> => {
-	const mutationKey = ['hostsList'];
-	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 hostsList>>,
-		{ data: BodyType<InframonitoringtypesHostsListRequestDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return hostsList(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type HostsListMutationResult = NonNullable<
-	Awaited<ReturnType<typeof hostsList>>
->;
-export type HostsListMutationBody = BodyType<InframonitoringtypesHostsListRequestDTO>;
-export type HostsListMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List Hosts for Infra Monitoring
- */
-export const useHostsList = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof hostsList>>,
-		TError,
-		{ data: BodyType<InframonitoringtypesHostsListRequestDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof hostsList>>,
-	TError,
-	{ data: BodyType<InframonitoringtypesHostsListRequestDTO> },
-	TContext
-> => {
-	const mutationOptions = getHostsListMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};

frontend/src/api/generated/services/routepolicies/index.ts

@@ -0,0 +1,482 @@
+/**
+ * ! Do not edit manually
+ * * The file has been auto-generated using Orval for SigNoz
+ * * regenerate with 'yarn generate:api'
+ * SigNoz
+ */
+import type {
+	InvalidateOptions,
+	MutationFunction,
+	QueryClient,
+	QueryFunction,
+	QueryKey,
+	UseMutationOptions,
+	UseMutationResult,
+	UseQueryOptions,
+	UseQueryResult,
+} from 'react-query';
+import { useMutation, useQuery } from 'react-query';
+
+import type { BodyType, ErrorType } from '../../../generatedAPIInstance';
+import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
+import type {
+	AlertmanagertypesPostableRoutePolicyDTO,
+	CreateRoutePolicy201,
+	DeleteRoutePolicyByIDPathParameters,
+	GetAllRoutePolicies200,
+	GetRoutePolicyByID200,
+	GetRoutePolicyByIDPathParameters,
+	RenderErrorResponseDTO,
+	UpdateRoutePolicy200,
+	UpdateRoutePolicyPathParameters,
+} from '../sigNoz.schemas';
+
+/**
+ * This endpoint lists all route policies for the organization
+ * @summary List route policies
+ */
+export const getAllRoutePolicies = (signal?: AbortSignal) => {
+	return GeneratedAPIInstance<GetAllRoutePolicies200>({
+		url: `/api/v1/route_policies`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getGetAllRoutePoliciesQueryKey = () => {
+	return [`/api/v1/route_policies`] as const;
+};
+
+export const getGetAllRoutePoliciesQueryOptions = <
+	TData = Awaited<ReturnType<typeof getAllRoutePolicies>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(options?: {
+	query?: UseQueryOptions<
+		Awaited<ReturnType<typeof getAllRoutePolicies>>,
+		TError,
+		TData
+	>;
+}) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey = queryOptions?.queryKey ?? getGetAllRoutePoliciesQueryKey();
+
+	const queryFn: QueryFunction<
+		Awaited<ReturnType<typeof getAllRoutePolicies>>
+	> = ({ signal }) => getAllRoutePolicies(signal);
+
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+		Awaited<ReturnType<typeof getAllRoutePolicies>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type GetAllRoutePoliciesQueryResult = NonNullable<
+	Awaited<ReturnType<typeof getAllRoutePolicies>>
+>;
+export type GetAllRoutePoliciesQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary List route policies
+ */
+
+export function useGetAllRoutePolicies<
+	TData = Awaited<ReturnType<typeof getAllRoutePolicies>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(options?: {
+	query?: UseQueryOptions<
+		Awaited<ReturnType<typeof getAllRoutePolicies>>,
+		TError,
+		TData
+	>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getGetAllRoutePoliciesQueryOptions(options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary List route policies
+ */
+export const invalidateGetAllRoutePolicies = async (
+	queryClient: QueryClient,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getGetAllRoutePoliciesQueryKey() },
+		options,
+	);
+
+	return queryClient;
+};
+
+/**
+ * This endpoint creates a route policy
+ * @summary Create route policy
+ */
+export const createRoutePolicy = (
+	alertmanagertypesPostableRoutePolicyDTO: BodyType<AlertmanagertypesPostableRoutePolicyDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<CreateRoutePolicy201>({
+		url: `/api/v1/route_policies`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: alertmanagertypesPostableRoutePolicyDTO,
+		signal,
+	});
+};
+
+export const getCreateRoutePolicyMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createRoutePolicy>>,
+		TError,
+		{ data: BodyType<AlertmanagertypesPostableRoutePolicyDTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof createRoutePolicy>>,
+	TError,
+	{ data: BodyType<AlertmanagertypesPostableRoutePolicyDTO> },
+	TContext
+> => {
+	const mutationKey = ['createRoutePolicy'];
+	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 createRoutePolicy>>,
+		{ data: BodyType<AlertmanagertypesPostableRoutePolicyDTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return createRoutePolicy(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type CreateRoutePolicyMutationResult = NonNullable<
+	Awaited<ReturnType<typeof createRoutePolicy>>
+>;
+export type CreateRoutePolicyMutationBody = BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
+export type CreateRoutePolicyMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Create route policy
+ */
+export const useCreateRoutePolicy = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createRoutePolicy>>,
+		TError,
+		{ data: BodyType<AlertmanagertypesPostableRoutePolicyDTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof createRoutePolicy>>,
+	TError,
+	{ data: BodyType<AlertmanagertypesPostableRoutePolicyDTO> },
+	TContext
+> => {
+	const mutationOptions = getCreateRoutePolicyMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint deletes a route policy by ID
+ * @summary Delete route policy
+ */
+export const deleteRoutePolicyByID = ({
+	id,
+}: DeleteRoutePolicyByIDPathParameters) => {
+	return GeneratedAPIInstance<void>({
+		url: `/api/v1/route_policies/${id}`,
+		method: 'DELETE',
+	});
+};
+
+export const getDeleteRoutePolicyByIDMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof deleteRoutePolicyByID>>,
+		TError,
+		{ pathParams: DeleteRoutePolicyByIDPathParameters },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof deleteRoutePolicyByID>>,
+	TError,
+	{ pathParams: DeleteRoutePolicyByIDPathParameters },
+	TContext
+> => {
+	const mutationKey = ['deleteRoutePolicyByID'];
+	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 deleteRoutePolicyByID>>,
+		{ pathParams: DeleteRoutePolicyByIDPathParameters }
+	> = (props) => {
+		const { pathParams } = props ?? {};
+
+		return deleteRoutePolicyByID(pathParams);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type DeleteRoutePolicyByIDMutationResult = NonNullable<
+	Awaited<ReturnType<typeof deleteRoutePolicyByID>>
+>;
+
+export type DeleteRoutePolicyByIDMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Delete route policy
+ */
+export const useDeleteRoutePolicyByID = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof deleteRoutePolicyByID>>,
+		TError,
+		{ pathParams: DeleteRoutePolicyByIDPathParameters },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof deleteRoutePolicyByID>>,
+	TError,
+	{ pathParams: DeleteRoutePolicyByIDPathParameters },
+	TContext
+> => {
+	const mutationOptions = getDeleteRoutePolicyByIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint returns a route policy by ID
+ * @summary Get route policy by ID
+ */
+export const getRoutePolicyByID = (
+	{ id }: GetRoutePolicyByIDPathParameters,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<GetRoutePolicyByID200>({
+		url: `/api/v1/route_policies/${id}`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getGetRoutePolicyByIDQueryKey = ({
+	id,
+}: GetRoutePolicyByIDPathParameters) => {
+	return [`/api/v1/route_policies/${id}`] as const;
+};
+
+export const getGetRoutePolicyByIDQueryOptions = <
+	TData = Awaited<ReturnType<typeof getRoutePolicyByID>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(
+	{ id }: GetRoutePolicyByIDPathParameters,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getRoutePolicyByID>>,
+			TError,
+			TData
+		>;
+	},
+) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey =
+		queryOptions?.queryKey ?? getGetRoutePolicyByIDQueryKey({ id });
+
+	const queryFn: QueryFunction<
+		Awaited<ReturnType<typeof getRoutePolicyByID>>
+	> = ({ signal }) => getRoutePolicyByID({ id }, signal);
+
+	return {
+		queryKey,
+		queryFn,
+		enabled: !!id,
+		...queryOptions,
+	} as UseQueryOptions<
+		Awaited<ReturnType<typeof getRoutePolicyByID>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type GetRoutePolicyByIDQueryResult = NonNullable<
+	Awaited<ReturnType<typeof getRoutePolicyByID>>
+>;
+export type GetRoutePolicyByIDQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Get route policy by ID
+ */
+
+export function useGetRoutePolicyByID<
+	TData = Awaited<ReturnType<typeof getRoutePolicyByID>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(
+	{ id }: GetRoutePolicyByIDPathParameters,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getRoutePolicyByID>>,
+			TError,
+			TData
+		>;
+	},
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getGetRoutePolicyByIDQueryOptions({ id }, options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary Get route policy by ID
+ */
+export const invalidateGetRoutePolicyByID = async (
+	queryClient: QueryClient,
+	{ id }: GetRoutePolicyByIDPathParameters,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getGetRoutePolicyByIDQueryKey({ id }) },
+		options,
+	);
+
+	return queryClient;
+};
+
+/**
+ * This endpoint updates a route policy by ID
+ * @summary Update route policy
+ */
+export const updateRoutePolicy = (
+	{ id }: UpdateRoutePolicyPathParameters,
+	alertmanagertypesPostableRoutePolicyDTO: BodyType<AlertmanagertypesPostableRoutePolicyDTO>,
+) => {
+	return GeneratedAPIInstance<UpdateRoutePolicy200>({
+		url: `/api/v1/route_policies/${id}`,
+		method: 'PUT',
+		headers: { 'Content-Type': 'application/json' },
+		data: alertmanagertypesPostableRoutePolicyDTO,
+	});
+};
+
+export const getUpdateRoutePolicyMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateRoutePolicy>>,
+		TError,
+		{
+			pathParams: UpdateRoutePolicyPathParameters;
+			data: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof updateRoutePolicy>>,
+	TError,
+	{
+		pathParams: UpdateRoutePolicyPathParameters;
+		data: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
+	},
+	TContext
+> => {
+	const mutationKey = ['updateRoutePolicy'];
+	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 updateRoutePolicy>>,
+		{
+			pathParams: UpdateRoutePolicyPathParameters;
+			data: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
+		}
+	> = (props) => {
+		const { pathParams, data } = props ?? {};
+
+		return updateRoutePolicy(pathParams, data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type UpdateRoutePolicyMutationResult = NonNullable<
+	Awaited<ReturnType<typeof updateRoutePolicy>>
+>;
+export type UpdateRoutePolicyMutationBody = BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
+export type UpdateRoutePolicyMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Update route policy
+ */
+export const useUpdateRoutePolicy = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateRoutePolicy>>,
+		TError,
+		{
+			pathParams: UpdateRoutePolicyPathParameters;
+			data: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof updateRoutePolicy>>,
+	TError,
+	{
+		pathParams: UpdateRoutePolicyPathParameters;
+		data: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
+	},
+	TContext
+> => {
+	const mutationOptions = getUpdateRoutePolicyMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};

pkg/alertmanager/handler.go

@@ -0,0 +1,31 @@
+package alertmanager
+
+import "net/http"
+
+type Handler interface {
+	GetAlerts(http.ResponseWriter, *http.Request)
+
+	TestReceiver(http.ResponseWriter, *http.Request)
+
+	ListChannels(http.ResponseWriter, *http.Request)
+
+	ListAllChannels(http.ResponseWriter, *http.Request)
+
+	GetChannelByID(http.ResponseWriter, *http.Request)
+
+	CreateChannel(http.ResponseWriter, *http.Request)
+
+	UpdateChannelByID(http.ResponseWriter, *http.Request)
+
+	DeleteChannelByID(http.ResponseWriter, *http.Request)
+
+	GetAllRoutePolicies(http.ResponseWriter, *http.Request)
+
+	GetRoutePolicyByID(http.ResponseWriter, *http.Request)
+
+	CreateRoutePolicy(http.ResponseWriter, *http.Request)
+
+	UpdateRoutePolicy(http.ResponseWriter, *http.Request)
+
+	DeleteRoutePolicyByID(http.ResponseWriter, *http.Request)
+}

pkg/alertmanager/signozalertmanager/handler.go

@@ -1,4 +1,4 @@
-package alertmanager
+package signozalertmanager
 
 import (
 	"context"
@@ -7,6 +7,7 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
@@ -15,17 +16,15 @@ import (
 	"github.com/gorilla/mux"
 )
 
-type API struct {
-	alertmanager Alertmanager
+type handler struct {
+	alertmanager alertmanager.Alertmanager
 }
 
-func NewAPI(alertmanager Alertmanager) *API {
-	return &API{
-		alertmanager: alertmanager,
-	}
+func NewHandler(alertmanager alertmanager.Alertmanager) alertmanager.Handler {
+	return &handler{alertmanager: alertmanager}
 }
 
-func (api *API) GetAlerts(rw http.ResponseWriter, req *http.Request) {
+func (handler *handler) GetAlerts(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
@@ -41,7 +40,7 @@ func (api *API) GetAlerts(rw http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	alerts, err := api.alertmanager.GetAlerts(ctx, claims.OrgID, params)
+	alerts, err := handler.alertmanager.GetAlerts(ctx, claims.OrgID, params)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -50,7 +49,7 @@ func (api *API) GetAlerts(rw http.ResponseWriter, req *http.Request) {
 	render.Success(rw, http.StatusOK, alerts)
 }
 
-func (api *API) TestReceiver(rw http.ResponseWriter, req *http.Request) {
+func (handler *handler) TestReceiver(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
@@ -73,7 +72,7 @@ func (api *API) TestReceiver(rw http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	err = api.alertmanager.TestReceiver(ctx, claims.OrgID, receiver)
+	err = handler.alertmanager.TestReceiver(ctx, claims.OrgID, receiver)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -82,7 +81,7 @@ func (api *API) TestReceiver(rw http.ResponseWriter, req *http.Request) {
 	render.Success(rw, http.StatusNoContent, nil)
 }
 
-func (api *API) ListChannels(rw http.ResponseWriter, req *http.Request) {
+func (handler *handler) ListChannels(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
@@ -92,7 +91,7 @@ func (api *API) ListChannels(rw http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	channels, err := api.alertmanager.ListChannels(ctx, claims.OrgID)
+	channels, err := handler.alertmanager.ListChannels(ctx, claims.OrgID)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -106,11 +105,11 @@ func (api *API) ListChannels(rw http.ResponseWriter, req *http.Request) {
 	render.Success(rw, http.StatusOK, channels)
 }
 
-func (api *API) ListAllChannels(rw http.ResponseWriter, req *http.Request) {
+func (handler *handler) ListAllChannels(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
-	channels, err := api.alertmanager.ListAllChannels(ctx)
+	channels, err := handler.alertmanager.ListAllChannels(ctx)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -119,7 +118,7 @@ func (api *API) ListAllChannels(rw http.ResponseWriter, req *http.Request) {
 	render.Success(rw, http.StatusOK, channels)
 }
 
-func (api *API) GetChannelByID(rw http.ResponseWriter, req *http.Request) {
+func (handler *handler) GetChannelByID(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
@@ -147,7 +146,7 @@ func (api *API) GetChannelByID(rw http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	channel, err := api.alertmanager.GetChannelByID(ctx, claims.OrgID, id)
+	channel, err := handler.alertmanager.GetChannelByID(ctx, claims.OrgID, id)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -156,7 +155,7 @@ func (api *API) GetChannelByID(rw http.ResponseWriter, req *http.Request) {
 	render.Success(rw, http.StatusOK, channel)
 }
 
-func (api *API) UpdateChannelByID(rw http.ResponseWriter, req *http.Request) {
+func (handler *handler) UpdateChannelByID(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
@@ -197,7 +196,7 @@ func (api *API) UpdateChannelByID(rw http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	err = api.alertmanager.UpdateChannelByReceiverAndID(ctx, claims.OrgID, receiver, id)
+	err = handler.alertmanager.UpdateChannelByReceiverAndID(ctx, claims.OrgID, receiver, id)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -206,7 +205,7 @@ func (api *API) UpdateChannelByID(rw http.ResponseWriter, req *http.Request) {
 	render.Success(rw, http.StatusNoContent, nil)
 }
 
-func (api *API) DeleteChannelByID(rw http.ResponseWriter, req *http.Request) {
+func (handler *handler) DeleteChannelByID(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
@@ -234,7 +233,7 @@ func (api *API) DeleteChannelByID(rw http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	err = api.alertmanager.DeleteChannelByID(ctx, claims.OrgID, id)
+	err = handler.alertmanager.DeleteChannelByID(ctx, claims.OrgID, id)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -243,7 +242,7 @@ func (api *API) DeleteChannelByID(rw http.ResponseWriter, req *http.Request) {
 	render.Success(rw, http.StatusNoContent, nil)
 }
 
-func (api *API) CreateChannel(rw http.ResponseWriter, req *http.Request) {
+func (handler *handler) CreateChannel(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
@@ -266,7 +265,7 @@ func (api *API) CreateChannel(rw http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	channel, err := api.alertmanager.CreateChannel(ctx, claims.OrgID, receiver)
+	channel, err := handler.alertmanager.CreateChannel(ctx, claims.OrgID, receiver)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -275,7 +274,7 @@ func (api *API) CreateChannel(rw http.ResponseWriter, req *http.Request) {
 	render.Success(rw, http.StatusCreated, channel)
 }
 
-func (api *API) CreateRoutePolicy(rw http.ResponseWriter, req *http.Request) {
+func (handler *handler) CreateRoutePolicy(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
@@ -300,7 +299,7 @@ func (api *API) CreateRoutePolicy(rw http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	result, err := api.alertmanager.CreateRoutePolicy(ctx, &policy)
+	result, err := handler.alertmanager.CreateRoutePolicy(ctx, &policy)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -309,11 +308,11 @@ func (api *API) CreateRoutePolicy(rw http.ResponseWriter, req *http.Request) {
 	render.Success(rw, http.StatusCreated, result)
 }
 
-func (api *API) GetAllRoutePolicies(rw http.ResponseWriter, req *http.Request) {
+func (handler *handler) GetAllRoutePolicies(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
-	policies, err := api.alertmanager.GetAllRoutePolicies(ctx)
+	policies, err := handler.alertmanager.GetAllRoutePolicies(ctx)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -322,7 +321,7 @@ func (api *API) GetAllRoutePolicies(rw http.ResponseWriter, req *http.Request) {
 	render.Success(rw, http.StatusOK, policies)
 }
 
-func (api *API) GetRoutePolicyByID(rw http.ResponseWriter, req *http.Request) {
+func (handler *handler) GetRoutePolicyByID(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
@@ -333,7 +332,7 @@ func (api *API) GetRoutePolicyByID(rw http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	policy, err := api.alertmanager.GetRoutePolicyByID(ctx, policyID)
+	policy, err := handler.alertmanager.GetRoutePolicyByID(ctx, policyID)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -342,7 +341,7 @@ func (api *API) GetRoutePolicyByID(rw http.ResponseWriter, req *http.Request) {
 	render.Success(rw, http.StatusOK, policy)
 }
 
-func (api *API) DeleteRoutePolicyByID(rw http.ResponseWriter, req *http.Request) {
+func (handler *handler) DeleteRoutePolicyByID(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
@@ -353,7 +352,7 @@ func (api *API) DeleteRoutePolicyByID(rw http.ResponseWriter, req *http.Request)
 		return
 	}
 
-	err := api.alertmanager.DeleteRoutePolicyByID(ctx, policyID)
+	err := handler.alertmanager.DeleteRoutePolicyByID(ctx, policyID)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -362,7 +361,7 @@ func (api *API) DeleteRoutePolicyByID(rw http.ResponseWriter, req *http.Request)
 	render.Success(rw, http.StatusNoContent, nil)
 }
 
-func (api *API) UpdateRoutePolicy(rw http.ResponseWriter, req *http.Request) {
+func (handler *handler) UpdateRoutePolicy(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
@@ -392,7 +391,7 @@ func (api *API) UpdateRoutePolicy(rw http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	result, err := api.alertmanager.UpdateRoutePolicyByID(ctx, policyID, &policy)
+	result, err := handler.alertmanager.UpdateRoutePolicyByID(ctx, policyID, &policy)
 	if err != nil {
 		render.Error(rw, err)
 		return

pkg/alertmanager/signozalertmanager/provider.go

@@ -309,8 +309,8 @@ func (provider *provider) CreateRoutePolicy(ctx context.Context, routeRequest *a
 	return &alertmanagertypes.GettableRoutePolicy{
 		PostableRoutePolicy: *routeRequest,
 		ID:                  route.ID.StringValue(),
-		CreatedAt:           &route.CreatedAt,
-		UpdatedAt:           &route.UpdatedAt,
+		CreatedAt:           route.CreatedAt,
+		UpdatedAt:           route.UpdatedAt,
 		CreatedBy:           &route.CreatedBy,
 		UpdatedBy:           &route.UpdatedBy,
 	}, nil
@@ -365,8 +365,8 @@ func (provider *provider) CreateRoutePolicies(ctx context.Context, routeRequests
 		results = append(results, &alertmanagertypes.GettableRoutePolicy{
 			PostableRoutePolicy: *routeRequest,
 			ID:                  route.ID.StringValue(),
-			CreatedAt:           &route.CreatedAt,
-			UpdatedAt:           &route.UpdatedAt,
+			CreatedAt:           route.CreatedAt,
+			UpdatedAt:           route.UpdatedAt,
 			CreatedBy:           &route.CreatedBy,
 			UpdatedBy:           &route.UpdatedBy,
 		})
@@ -405,8 +405,8 @@ func (provider *provider) GetRoutePolicyByID(ctx context.Context, routeID string
 			Tags:           route.Tags,
 		},
 		ID:        route.ID.StringValue(),
-		CreatedAt: &route.CreatedAt,
-		UpdatedAt: &route.UpdatedAt,
+		CreatedAt: route.CreatedAt,
+		UpdatedAt: route.UpdatedAt,
 		CreatedBy: &route.CreatedBy,
 		UpdatedBy: &route.UpdatedBy,
 	}, nil
@@ -439,8 +439,8 @@ func (provider *provider) GetAllRoutePolicies(ctx context.Context) ([]*alertmana
 				Tags:           route.Tags,
 			},
 			ID:        route.ID.StringValue(),
-			CreatedAt: &route.CreatedAt,
-			UpdatedAt: &route.UpdatedAt,
+			CreatedAt: route.CreatedAt,
+			UpdatedAt: route.UpdatedAt,
 			CreatedBy: &route.CreatedBy,
 			UpdatedBy: &route.UpdatedBy,
 		})
@@ -508,8 +508,8 @@ func (provider *provider) UpdateRoutePolicyByID(ctx context.Context, routeID str
 	return &alertmanagertypes.GettableRoutePolicy{
 		PostableRoutePolicy: *route,
 		ID:                  updatedRoute.ID.StringValue(),
-		CreatedAt:           &updatedRoute.CreatedAt,
-		UpdatedAt:           &updatedRoute.UpdatedAt,
+		CreatedAt:           updatedRoute.CreatedAt,
+		UpdatedAt:           updatedRoute.UpdatedAt,
 		CreatedBy:           &updatedRoute.CreatedBy,
 		UpdatedBy:           &updatedRoute.UpdatedBy,
 	}, nil

pkg/apiserver/signozapiserver/alertmanager.go

@@ -0,0 +1,235 @@
+package signozapiserver
+
+import (
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/http/handler"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/gorilla/mux"
+)
+
+func (provider *provider) addAlertmanagerRoutes(router *mux.Router) error {
+	if err := router.Handle("/api/v1/channels", handler.New(provider.authZ.ViewAccess(provider.alertmanagerHandler.ListChannels), handler.OpenAPIDef{
+		ID:                  "ListChannels",
+		Tags:                []string{"channels"},
+		Summary:             "List notification channels",
+		Description:         "This endpoint lists all notification channels for the organization",
+		Request:             nil,
+		RequestContentType:  "",
+		Response:            make([]*alertmanagertypes.Channel, 0),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{},
+		Deprecated:          false,
+		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+	})).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/channels/{id}", handler.New(provider.authZ.ViewAccess(provider.alertmanagerHandler.GetChannelByID), handler.OpenAPIDef{
+		ID:                  "GetChannelByID",
+		Tags:                []string{"channels"},
+		Summary:             "Get notification channel by ID",
+		Description:         "This endpoint returns a notification channel by ID",
+		Request:             nil,
+		RequestContentType:  "",
+		Response:            new(alertmanagertypes.Channel),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{http.StatusNotFound},
+		Deprecated:          false,
+		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+	})).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/channels", handler.New(provider.authZ.AdminAccess(provider.alertmanagerHandler.CreateChannel), handler.OpenAPIDef{
+		ID:                  "CreateChannel",
+		Tags:                []string{"channels"},
+		Summary:             "Create notification channel",
+		Description:         "This endpoint creates a notification channel",
+		Request:             new(alertmanagertypes.Receiver),
+		RequestContentType:  "application/json",
+		Response:            new(alertmanagertypes.Channel),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusCreated,
+		ErrorStatusCodes:    []int{http.StatusBadRequest},
+		Deprecated:          false,
+		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
+	})).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/channels/{id}", handler.New(provider.authZ.AdminAccess(provider.alertmanagerHandler.UpdateChannelByID), handler.OpenAPIDef{
+		ID:                  "UpdateChannelByID",
+		Tags:                []string{"channels"},
+		Summary:             "Update notification channel",
+		Description:         "This endpoint updates a notification channel by ID",
+		Request:             new(alertmanagertypes.Receiver),
+		RequestContentType:  "application/json",
+		Response:            nil,
+		ResponseContentType: "",
+		SuccessStatusCode:   http.StatusNoContent,
+		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
+		Deprecated:          false,
+		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
+	})).Methods(http.MethodPut).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/channels/{id}", handler.New(provider.authZ.AdminAccess(provider.alertmanagerHandler.DeleteChannelByID), handler.OpenAPIDef{
+		ID:                  "DeleteChannelByID",
+		Tags:                []string{"channels"},
+		Summary:             "Delete notification channel",
+		Description:         "This endpoint deletes a notification channel by ID",
+		Request:             nil,
+		RequestContentType:  "",
+		Response:            nil,
+		ResponseContentType: "",
+		SuccessStatusCode:   http.StatusNoContent,
+		ErrorStatusCodes:    []int{http.StatusNotFound},
+		Deprecated:          false,
+		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
+	})).Methods(http.MethodDelete).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/channels/test", handler.New(provider.authZ.EditAccess(provider.alertmanagerHandler.TestReceiver), handler.OpenAPIDef{
+		ID:                  "TestChannel",
+		Tags:                []string{"channels"},
+		Summary:             "Test notification channel",
+		Description:         "This endpoint tests a notification channel by sending a test notification",
+		Request:             new(alertmanagertypes.Receiver),
+		RequestContentType:  "application/json",
+		Response:            nil,
+		ResponseContentType: "",
+		SuccessStatusCode:   http.StatusNoContent,
+		ErrorStatusCodes:    []int{http.StatusBadRequest},
+		Deprecated:          false,
+		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+	})).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/testChannel", handler.New(provider.authZ.EditAccess(provider.alertmanagerHandler.TestReceiver), handler.OpenAPIDef{
+		ID:                  "TestChannelDeprecated",
+		Tags:                []string{"channels"},
+		Summary:             "Test notification channel (deprecated)",
+		Description:         "Deprecated: use /api/v1/channels/test instead",
+		Request:             new(alertmanagertypes.Receiver),
+		RequestContentType:  "application/json",
+		Response:            nil,
+		ResponseContentType: "",
+		SuccessStatusCode:   http.StatusNoContent,
+		ErrorStatusCodes:    []int{http.StatusBadRequest},
+		Deprecated:          true,
+		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+	})).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/route_policies", handler.New(provider.authZ.ViewAccess(provider.alertmanagerHandler.GetAllRoutePolicies), handler.OpenAPIDef{
+		ID:                  "GetAllRoutePolicies",
+		Tags:                []string{"routepolicies"},
+		Summary:             "List route policies",
+		Description:         "This endpoint lists all route policies for the organization",
+		Request:             nil,
+		RequestContentType:  "",
+		Response:            make([]*alertmanagertypes.GettableRoutePolicy, 0),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{},
+		Deprecated:          false,
+		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+	})).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/route_policies/{id}", handler.New(provider.authZ.ViewAccess(provider.alertmanagerHandler.GetRoutePolicyByID), handler.OpenAPIDef{
+		ID:                  "GetRoutePolicyByID",
+		Tags:                []string{"routepolicies"},
+		Summary:             "Get route policy by ID",
+		Description:         "This endpoint returns a route policy by ID",
+		Request:             nil,
+		RequestContentType:  "",
+		Response:            new(alertmanagertypes.GettableRoutePolicy),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{http.StatusNotFound},
+		Deprecated:          false,
+		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+	})).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/route_policies", handler.New(provider.authZ.AdminAccess(provider.alertmanagerHandler.CreateRoutePolicy), handler.OpenAPIDef{
+		ID:                  "CreateRoutePolicy",
+		Tags:                []string{"routepolicies"},
+		Summary:             "Create route policy",
+		Description:         "This endpoint creates a route policy",
+		Request:             new(alertmanagertypes.PostableRoutePolicy),
+		RequestContentType:  "application/json",
+		Response:            new(alertmanagertypes.GettableRoutePolicy),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusCreated,
+		ErrorStatusCodes:    []int{http.StatusBadRequest},
+		Deprecated:          false,
+		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
+	})).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/route_policies/{id}", handler.New(provider.authZ.AdminAccess(provider.alertmanagerHandler.UpdateRoutePolicy), handler.OpenAPIDef{
+		ID:                  "UpdateRoutePolicy",
+		Tags:                []string{"routepolicies"},
+		Summary:             "Update route policy",
+		Description:         "This endpoint updates a route policy by ID",
+		Request:             new(alertmanagertypes.PostableRoutePolicy),
+		RequestContentType:  "application/json",
+		Response:            new(alertmanagertypes.GettableRoutePolicy),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
+		Deprecated:          false,
+		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
+	})).Methods(http.MethodPut).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/route_policies/{id}", handler.New(provider.authZ.AdminAccess(provider.alertmanagerHandler.DeleteRoutePolicyByID), handler.OpenAPIDef{
+		ID:                  "DeleteRoutePolicyByID",
+		Tags:                []string{"routepolicies"},
+		Summary:             "Delete route policy",
+		Description:         "This endpoint deletes a route policy by ID",
+		Request:             nil,
+		RequestContentType:  "",
+		Response:            nil,
+		ResponseContentType: "",
+		SuccessStatusCode:   http.StatusNoContent,
+		ErrorStatusCodes:    []int{http.StatusNotFound},
+		Deprecated:          false,
+		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
+	})).Methods(http.MethodDelete).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/alerts", handler.New(provider.authZ.ViewAccess(provider.alertmanagerHandler.GetAlerts), handler.OpenAPIDef{
+		ID:                  "GetAlerts",
+		Tags:                []string{"alerts"},
+		Summary:             "Get alerts",
+		Description:         "This endpoint returns alerts for the organization",
+		Request:             nil,
+		RequestContentType:  "",
+		Response:            make(alertmanagertypes.DeprecatedGettableAlerts, 0),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{},
+		Deprecated:          false,
+		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+	})).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/apiserver/signozapiserver/inframonitoring.go

@@ -1,33 +0,0 @@
-package signozapiserver
-
-import (
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/http/handler"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
-	"github.com/gorilla/mux"
-)
-
-func (provider *provider) addInfraMonitoringRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v2/infra_monitoring/hosts", handler.New(
-		provider.authZ.ViewAccess(provider.infraMonitoringHandler.HostsList),
-		handler.OpenAPIDef{
-			ID:                  "HostsList",
-			Tags:                []string{"infra-monitoring"},
-			Summary:             "List Hosts for Infra Monitoring",
-			Description:         "Returns a paginated list of hosts with key infrastructure metrics: CPU usage (%), memory usage (%), I/O wait (%), disk usage (%), and 15-minute load average. Each host includes its current status (active/inactive based on metrics reported in the last 10 minutes) and metadata attributes (e.g., os.type). Supports filtering via a filter expression, filtering by host status, custom groupBy to aggregate hosts by any attribute, ordering by any of the five metrics, and pagination via offset/limit. The response type is 'list' for the default host.name grouping or 'grouped_list' for custom groupBy keys. Also reports missing required metrics and whether the requested time range falls before the data retention boundary.",
-			Request:             new(inframonitoringtypes.HostsListRequest),
-			RequestContentType:  "application/json",
-			Response:            new(inframonitoringtypes.HostsListResponse),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusInternalServerError},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		})).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
-	return nil
-}

pkg/apiserver/signozapiserver/provider.go

@@ -3,6 +3,7 @@ package signozapiserver
 import (
 	"context"
 
+	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/apiserver"
 	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/factory"
@@ -16,7 +17,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/fields"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/promote"
@@ -48,7 +48,6 @@ type provider struct {
 	dashboardModule         dashboard.Module
 	dashboardHandler        dashboard.Handler
 	metricsExplorerHandler  metricsexplorer.Handler
-	infraMonitoringHandler  inframonitoring.Handler
 	gatewayHandler          gateway.Handler
 	fieldsHandler           fields.Handler
 	authzHandler            authz.Handler
@@ -59,6 +58,7 @@ type provider struct {
 	factoryHandler          factory.Handler
 	cloudIntegrationHandler cloudintegration.Handler
 	ruleStateHistoryHandler rulestatehistory.Handler
+	alertmanagerHandler     alertmanager.Handler
 }
 
 func NewFactory(
@@ -75,7 +75,6 @@ func NewFactory(
 	dashboardModule dashboard.Module,
 	dashboardHandler dashboard.Handler,
 	metricsExplorerHandler metricsexplorer.Handler,
-	infraMonitoringHandler inframonitoring.Handler,
 	gatewayHandler gateway.Handler,
 	fieldsHandler fields.Handler,
 	authzHandler authz.Handler,
@@ -86,6 +85,7 @@ func NewFactory(
 	factoryHandler factory.Handler,
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
+	alertmanagerHandler alertmanager.Handler,
 ) factory.ProviderFactory[apiserver.APIServer, apiserver.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("signoz"), func(ctx context.Context, providerSettings factory.ProviderSettings, config apiserver.Config) (apiserver.APIServer, error) {
 		return newProvider(
@@ -105,7 +105,6 @@ func NewFactory(
 			dashboardModule,
 			dashboardHandler,
 			metricsExplorerHandler,
-			infraMonitoringHandler,
 			gatewayHandler,
 			fieldsHandler,
 			authzHandler,
@@ -116,6 +115,7 @@ func NewFactory(
 			factoryHandler,
 			cloudIntegrationHandler,
 			ruleStateHistoryHandler,
+			alertmanagerHandler,
 		)
 	})
 }
@@ -137,7 +137,6 @@ func newProvider(
 	dashboardModule dashboard.Module,
 	dashboardHandler dashboard.Handler,
 	metricsExplorerHandler metricsexplorer.Handler,
-	infraMonitoringHandler inframonitoring.Handler,
 	gatewayHandler gateway.Handler,
 	fieldsHandler fields.Handler,
 	authzHandler authz.Handler,
@@ -148,6 +147,7 @@ func newProvider(
 	factoryHandler factory.Handler,
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
+	alertmanagerHandler alertmanager.Handler,
 ) (apiserver.APIServer, error) {
 	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/apiserver/signozapiserver")
 	router := mux.NewRouter().UseEncodedPath()
@@ -167,7 +167,6 @@ func newProvider(
 		dashboardModule:         dashboardModule,
 		dashboardHandler:        dashboardHandler,
 		metricsExplorerHandler:  metricsExplorerHandler,
-		infraMonitoringHandler:  infraMonitoringHandler,
 		gatewayHandler:          gatewayHandler,
 		fieldsHandler:           fieldsHandler,
 		authzHandler:            authzHandler,
@@ -178,6 +177,7 @@ func newProvider(
 		factoryHandler:          factoryHandler,
 		cloudIntegrationHandler: cloudIntegrationHandler,
 		ruleStateHistoryHandler: ruleStateHistoryHandler,
+		alertmanagerHandler:     alertmanagerHandler,
 	}
 
 	provider.authZ = middleware.NewAuthZ(settings.Logger(), orgGetter, authz)
@@ -234,10 +234,6 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
-	if err := provider.addInfraMonitoringRoutes(router); err != nil {
-		return err
-	}
-
 	if err := provider.addGatewayRoutes(router); err != nil {
 		return err
 	}
@@ -282,6 +278,10 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
+	if err := provider.addAlertmanagerRoutes(router); err != nil {
+		return err
+	}
+
 	return nil
 }
 

pkg/modules/inframonitoring/config.go

@@ -1,33 +0,0 @@
-package inframonitoring
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-)
-
-type Config struct {
-	TelemetryStore TelemetryStoreConfig `mapstructure:"telemetrystore"`
-}
-
-type TelemetryStoreConfig struct {
-	Threads int `mapstructure:"threads"`
-}
-
-func NewConfigFactory() factory.ConfigFactory {
-	return factory.NewConfigFactory(factory.MustNewName("inframonitoring"), newConfig)
-}
-
-func newConfig() factory.Config {
-	return Config{
-		TelemetryStore: TelemetryStoreConfig{
-			Threads: 8,
-		},
-	}
-}
-
-func (c Config) Validate() error {
-	if c.TelemetryStore.Threads <= 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "inframonitoring.telemetrystore.threads must be positive, got %d", c.TelemetryStore.Threads)
-	}
-	return nil
-}

pkg/modules/inframonitoring/implinframonitoring/commonmethods.go

@@ -1,277 +0,0 @@
-package implinframonitoring
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
-	"github.com/SigNoz/signoz/pkg/types/metrictypes"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/huandu/go-sqlbuilder"
-)
-
-func (m *module) buildFilterClause(ctx context.Context, filter *qbtypes.Filter, startMillis, endMillis int64) (*sqlbuilder.WhereClause, error) {
-	expression := ""
-	if filter != nil {
-		expression = strings.TrimSpace(filter.Expression)
-	}
-	if expression == "" {
-		return sqlbuilder.NewWhereClause(), nil
-	}
-
-	whereClauseSelectors := querybuilder.QueryStringToKeysSelectors(expression)
-	for idx := range whereClauseSelectors {
-		whereClauseSelectors[idx].Signal = telemetrytypes.SignalMetrics
-		whereClauseSelectors[idx].SelectorMatchType = telemetrytypes.FieldSelectorMatchTypeExact
-	}
-
-	keys, _, err := m.telemetryMetadataStore.GetKeysMulti(ctx, whereClauseSelectors)
-	if err != nil {
-		return nil, err
-	}
-
-	opts := querybuilder.FilterExprVisitorOpts{
-		Context:          ctx,
-		Logger:           m.logger,
-		FieldMapper:      m.fieldMapper,
-		ConditionBuilder: m.condBuilder,
-		FullTextColumn:   &telemetrytypes.TelemetryFieldKey{Name: "metric_name", FieldContext: telemetrytypes.FieldContextMetric},
-		FieldKeys:        keys,
-		StartNs:          querybuilder.ToNanoSecs(uint64(startMillis)),
-		EndNs:            querybuilder.ToNanoSecs(uint64(endMillis)),
-	}
-
-	whereClause, err := querybuilder.PrepareWhereClause(expression, opts)
-	if err != nil {
-		return nil, err
-	}
-
-	if whereClause == nil || whereClause.WhereClause == nil {
-		return sqlbuilder.NewWhereClause(), nil
-	}
-
-	return whereClause.WhereClause, nil
-}
-
-// NOTE: this method is not specific to infra monitoring — it queries attributes_metadata generically.
-// Consider moving to telemetryMetaStore when a second use case emerges.
-//
-// getMetricsExistenceAndEarliestTime checks which of the given metric names have been
-// reported. It returns a list of missing metrics (those not found or with zero count)
-// and the earliest first-reported timestamp across all present metrics.
-// When all metrics are missing, minFirstReportedUnixMilli is 0.
-// TODO(nikhilmantri0902, srikanthccv): This method was designed this way because querier errors if any of the metrics
-// in the querier list was never sent, the QueryRange call throws not found error. Modify this method, if QueryRange
-// behaviour changes towards this.
-func (m *module) getMetricsExistenceAndEarliestTime(ctx context.Context, metricNames []string) ([]string, uint64, error) {
-	if len(metricNames) == 0 {
-		return nil, 0, nil
-	}
-
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select("metric_name", "count(*) AS cnt", "min(first_reported_unix_milli) AS min_first_reported")
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.AttributesMetadataTableName))
-	sb.Where(sb.In("metric_name", sqlbuilder.List(metricNames)))
-	sb.GroupBy("metric_name")
-
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-
-	rows, err := m.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
-	if err != nil {
-		return nil, 0, err
-	}
-	defer rows.Close()
-
-	type metricInfo struct {
-		count            uint64
-		minFirstReported uint64
-	}
-	found := make(map[string]metricInfo, len(metricNames))
-
-	for rows.Next() {
-		var name string
-		var cnt, minFR uint64
-		if err := rows.Scan(&name, &cnt, &minFR); err != nil {
-			return nil, 0, err
-		}
-		found[name] = metricInfo{count: cnt, minFirstReported: minFR}
-	}
-	if err := rows.Err(); err != nil {
-		return nil, 0, err
-	}
-
-	var missingMetrics []string
-	var globalMinFirstReported uint64
-	for _, name := range metricNames {
-		info, ok := found[name]
-		if !ok || info.count == 0 {
-			missingMetrics = append(missingMetrics, name)
-			continue
-		}
-		if globalMinFirstReported == 0 || info.minFirstReported < globalMinFirstReported {
-			globalMinFirstReported = info.minFirstReported
-		}
-	}
-
-	return missingMetrics, globalMinFirstReported, nil
-}
-
-// getMetadata fetches the latest values of additionalCols for each unique combination of groupBy keys,
-// within the given time range and metric names. It uses argMax(tuple(...), unix_milli) to ensure
-// we always pick attribute values from the latest timestamp for each group.
-// The returned map has a composite key of groupBy column values joined by "\x00" (null byte),
-// mapping to a flat map of attr_name -> attr_value (includes both groupBy and additional cols).
-func (m *module) getMetadata(
-	ctx context.Context,
-	metricNames []string,
-	groupBy []qbtypes.GroupByKey,
-	additionalCols []string,
-	filter *qbtypes.Filter,
-	startMs, endMs int64,
-) (map[string]map[string]string, error) {
-	if len(metricNames) == 0 {
-		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "metricNames must not be empty")
-	}
-	if len(groupBy) == 0 {
-		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "groupBy must not be empty")
-	}
-
-	// Pick the optimal timeseries table based on time range; also get adjusted start.
-	adjustedStart, adjustedEnd, distributedTableName, _ := telemetrymetrics.WhichTSTableToUse(
-		uint64(startMs), uint64(endMs), nil,
-	)
-
-	// Build a fingerprint subquery against the samples table using the original
-	// (non-adjusted) time range. The time_series tables are ReplacingMergeTrees
-	// with bucketed granularity, so WhichTSTableToUse widens the window — this
-	// subquery restricts to fingerprints actually active in the requested range.
-	samplesTableName := telemetrymetrics.WhichSamplesTableToUse(
-		uint64(startMs), uint64(endMs),
-		metrictypes.UnspecifiedType,
-		metrictypes.TimeAggregationUnspecified,
-		nil,
-	)
-	localSamplesTable := strings.TrimPrefix(samplesTableName, "distributed_")
-	fpSB := sqlbuilder.NewSelectBuilder()
-	fpSB.Select("DISTINCT fingerprint")
-	fpSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localSamplesTable))
-	fpSB.Where(
-		fpSB.In("metric_name", sqlbuilder.List(metricNames)),
-		fpSB.GE("unix_milli", startMs),
-		fpSB.L("unix_milli", endMs),
-	)
-
-	// Flatten groupBy keys to string names for SQL expressions and result scanning.
-	groupByCols := make([]string, len(groupBy))
-	for i, key := range groupBy {
-		groupByCols[i] = key.Name
-	}
-	allCols := append(groupByCols, additionalCols...)
-
-	// --- Build inner query ---
-	innerSB := sqlbuilder.NewSelectBuilder()
-
-	// Inner SELECT columns: JSONExtractString for each groupBy col + argMax(tuple(...)) for additional cols
-	innerSelectCols := make([]string, 0, len(groupByCols)+1)
-	for _, col := range groupByCols {
-		innerSelectCols = append(innerSelectCols,
-			fmt.Sprintf("JSONExtractString(labels, %s) AS %s", innerSB.Var(col), quoteIdentifier(col)),
-		)
-	}
-
-	// Build the argMax(tuple(...), unix_milli) expression for all additional cols
-	if len(additionalCols) > 0 {
-		tupleArgs := make([]string, 0, len(additionalCols))
-		for _, col := range additionalCols {
-			tupleArgs = append(tupleArgs, fmt.Sprintf("JSONExtractString(labels, %s)", innerSB.Var(col)))
-		}
-		innerSelectCols = append(innerSelectCols,
-			fmt.Sprintf("argMax(tuple(%s), unix_milli) AS latest_attrs", strings.Join(tupleArgs, ", ")),
-		)
-	}
-
-	innerSB.Select(innerSelectCols...)
-	innerSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTableName))
-	innerSB.Where(
-		innerSB.In("metric_name", sqlbuilder.List(metricNames)),
-		innerSB.GE("unix_milli", adjustedStart),
-		innerSB.L("unix_milli", adjustedEnd),
-		fmt.Sprintf("fingerprint IN (%s)", innerSB.Var(fpSB)),
-	)
-
-	// Apply optional filter expression
-	if filter != nil && strings.TrimSpace(filter.Expression) != "" {
-		filterClause, err := m.buildFilterClause(ctx, filter, startMs, endMs)
-		if err != nil {
-			return nil, err
-		}
-		if filterClause != nil {
-			innerSB.AddWhereClause(filterClause)
-		}
-	}
-
-	groupByAliases := make([]string, 0, len(groupByCols))
-	for _, col := range groupByCols {
-		groupByAliases = append(groupByAliases, quoteIdentifier(col))
-	}
-	innerSB.GroupBy(groupByAliases...)
-
-	innerQuery, innerArgs := innerSB.BuildWithFlavor(sqlbuilder.ClickHouse)
-
-	// --- Build outer query ---
-	// Outer SELECT columns: groupBy cols directly + tupleElement(latest_attrs, N) for each additionalCol
-	outerSelectCols := make([]string, 0, len(allCols))
-	for _, col := range groupByCols {
-		outerSelectCols = append(outerSelectCols, quoteIdentifier(col))
-	}
-	for i, col := range additionalCols {
-		outerSelectCols = append(outerSelectCols,
-			fmt.Sprintf("tupleElement(latest_attrs, %d) AS %s", i+1, quoteIdentifier(col)),
-		)
-	}
-
-	outerSB := sqlbuilder.NewSelectBuilder()
-	outerSB.Select(outerSelectCols...)
-	outerSB.From(fmt.Sprintf("(%s)", innerQuery))
-
-	outerQuery, _ := outerSB.BuildWithFlavor(sqlbuilder.ClickHouse)
-	// All ? params are in innerArgs; outer query introduces none of its own.
-
-	rows, err := m.telemetryStore.ClickhouseDB().Query(ctx, outerQuery, innerArgs...)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	result := make(map[string]map[string]string)
-
-	for rows.Next() {
-		row := make([]string, len(allCols))
-		scanPtrs := make([]any, len(row))
-		for i := range row {
-			scanPtrs[i] = &row[i]
-		}
-
-		if err := rows.Scan(scanPtrs...); err != nil {
-			return nil, err
-		}
-
-		compositeKey := compositeKeyFromList(row[:len(groupByCols)])
-
-		attrMap := make(map[string]string, len(allCols))
-		for i, col := range allCols {
-			attrMap[col] = row[i]
-		}
-		result[compositeKey] = attrMap
-	}
-
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-
-	return result, nil
-}

pkg/modules/inframonitoring/implinframonitoring/handler.go

@@ -1,48 +0,0 @@
-package implinframonitoring
-
-import (
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/http/binding"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type handler struct {
-	module inframonitoring.Module
-}
-
-// NewHandler returns an inframonitoring.Handler implementation.
-func NewHandler(m inframonitoring.Module) inframonitoring.Handler {
-	return &handler{
-		module: m,
-	}
-}
-
-func (h *handler) HostsList(rw http.ResponseWriter, req *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(req.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-
-	var parsedReq inframonitoringtypes.HostsListRequest
-	if err := binding.JSON.BindBody(req.Body, &parsedReq); err != nil {
-		render.Error(rw, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "failed to parse request body"))
-		return
-	}
-
-	result, err := h.module.HostsList(req.Context(), orgID, &parsedReq)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, result)
-}

pkg/modules/inframonitoring/implinframonitoring/helpers.go

@@ -1,292 +0,0 @@
-package implinframonitoring
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-)
-
-// quoteIdentifier wraps s in backticks for use as a ClickHouse identifier,
-// escaping any embedded backticks by doubling them.
-func quoteIdentifier(s string) string {
-	return fmt.Sprintf("`%s`", strings.ReplaceAll(s, "`", "``"))
-}
-
-type rankedGroup struct {
-	labels map[string]string
-	value  float64
-}
-
-func isKeyInGroupByAttrs(groupByAttrs []qbtypes.GroupByKey, key string) bool {
-	for _, groupBy := range groupByAttrs {
-		if groupBy.Name == key {
-			return true
-		}
-	}
-	return false
-}
-
-func mergeFilterExpressions(queryFilterExpr, reqFilterExpr string) string {
-	queryFilterExpr = strings.TrimSpace(queryFilterExpr)
-	reqFilterExpr = strings.TrimSpace(reqFilterExpr)
-	if queryFilterExpr == "" {
-		return reqFilterExpr
-	}
-	if reqFilterExpr == "" {
-		return queryFilterExpr
-	}
-	return fmt.Sprintf("(%s) AND (%s)", queryFilterExpr, reqFilterExpr)
-}
-
-// compositeKeyFromList builds a composite key by joining the given parts
-// with a null byte separator. This is the canonical way to construct
-// composite keys for group identification across the infra monitoring module.
-func compositeKeyFromList(parts []string) string {
-	return strings.Join(parts, "\x00")
-}
-
-// compositeKeyFromLabels builds a composite key from a label map by extracting
-// the value for each groupBy key in order and joining them via compositeKeyFromList.
-func compositeKeyFromLabels(labels map[string]string, groupBy []qbtypes.GroupByKey) string {
-	parts := make([]string, len(groupBy))
-	for i, key := range groupBy {
-		parts[i] = labels[key.Name]
-	}
-	return compositeKeyFromList(parts)
-}
-
-// parseAndSortGroups extracts group label maps from a ScalarData response and
-// sorts them by the ranking query's aggregation value.
-func parseAndSortGroups(
-	resp *qbtypes.QueryRangeResponse,
-	rankingQueryName string,
-	groupBy []qbtypes.GroupByKey,
-	direction qbtypes.OrderDirection,
-) []rankedGroup {
-	if resp == nil || len(resp.Data.Results) == 0 {
-		return nil
-	}
-
-	// Find the ScalarData that contains the ranking column.
-	var sd *qbtypes.ScalarData
-	for _, r := range resp.Data.Results {
-		candidate, ok := r.(*qbtypes.ScalarData)
-		if !ok || candidate == nil {
-			continue
-		}
-		for _, col := range candidate.Columns {
-			if col.Type == qbtypes.ColumnTypeAggregation && col.QueryName == rankingQueryName {
-				sd = candidate
-				break
-			}
-		}
-		if sd != nil {
-			break
-		}
-	}
-	if sd == nil || len(sd.Data) == 0 {
-		return nil
-	}
-
-	groupColIndices := make(map[string]int)
-	rankingColIdx := -1
-	for i, col := range sd.Columns {
-		if col.Type == qbtypes.ColumnTypeGroup {
-			groupColIndices[col.Name] = i
-		}
-		if col.Type == qbtypes.ColumnTypeAggregation && col.QueryName == rankingQueryName {
-			rankingColIdx = i
-		}
-	}
-	if rankingColIdx == -1 {
-		return nil
-	}
-
-	groups := make([]rankedGroup, 0, len(sd.Data))
-	for _, row := range sd.Data {
-		labels := make(map[string]string, len(groupBy))
-		for _, key := range groupBy {
-			if idx, ok := groupColIndices[key.Name]; ok && idx < len(row) {
-				labels[key.Name] = fmt.Sprintf("%v", row[idx])
-			}
-		}
-		var value float64
-		if rankingColIdx < len(row) {
-			if v, ok := row[rankingColIdx].(float64); ok {
-				value = v
-			}
-		}
-		groups = append(groups, rankedGroup{labels: labels, value: value})
-	}
-
-	sort.Slice(groups, func(i, j int) bool {
-		if direction == qbtypes.OrderDirectionAsc {
-			return groups[i].value < groups[j].value
-		}
-		return groups[i].value > groups[j].value
-	})
-
-	return groups
-}
-
-// paginateWithBackfill returns the page of groups for [offset, offset+limit).
-// The virtual sorted list is: metric-ranked groups first, then metadata-only
-// groups (those in metadataMap but not in metric results) sorted alphabetically.
-func paginateWithBackfill(
-	metricGroups []rankedGroup,
-	metadataMap map[string]map[string]string,
-	groupBy []qbtypes.GroupByKey,
-	offset, limit int,
-) []map[string]string {
-	metricKeySet := make(map[string]bool, len(metricGroups))
-	for _, g := range metricGroups {
-		metricKeySet[compositeKeyFromLabels(g.labels, groupBy)] = true
-	}
-
-	metadataOnlyKeys := make([]string, 0)
-	for compositeKey := range metadataMap {
-		if !metricKeySet[compositeKey] {
-			metadataOnlyKeys = append(metadataOnlyKeys, compositeKey)
-		}
-	}
-	sort.Strings(metadataOnlyKeys)
-
-	totalMetric := len(metricGroups)
-	totalAll := totalMetric + len(metadataOnlyKeys)
-
-	end := offset + limit
-	if end > totalAll {
-		end = totalAll
-	}
-	if offset >= totalAll {
-		return nil
-	}
-
-	pageGroups := make([]map[string]string, 0, end-offset)
-	for i := offset; i < end; i++ {
-		if i < totalMetric {
-			pageGroups = append(pageGroups, metricGroups[i].labels)
-		} else {
-			compositeKey := metadataOnlyKeys[i-totalMetric]
-			attrs := metadataMap[compositeKey]
-			labels := make(map[string]string, len(groupBy))
-			for _, key := range groupBy {
-				labels[key.Name] = attrs[key.Name]
-			}
-			pageGroups = append(pageGroups, labels)
-		}
-	}
-	return pageGroups
-}
-
-// buildFullQueryRequest creates a QueryRangeRequest for all metrics,
-// restricted to the given page of groups via an IN filter.
-// Accepts primitive fields so it can be reused across different v2 APIs
-// (hosts, pods, etc.).
-func buildFullQueryRequest(
-	start int64,
-	end int64,
-	filterExpr string,
-	groupBy []qbtypes.GroupByKey,
-	pageGroups []map[string]string,
-	tableListQuery *qbtypes.QueryRangeRequest,
-) *qbtypes.QueryRangeRequest {
-	groupValues := make(map[string][]string)
-	for _, labels := range pageGroups {
-		for k, v := range labels {
-			groupValues[k] = append(groupValues[k], v)
-		}
-	}
-
-	inClauses := make([]string, 0, len(groupValues))
-	for key, values := range groupValues {
-		quoted := make([]string, len(values))
-		for i, v := range values {
-			quoted[i] = fmt.Sprintf("'%s'", v)
-		}
-		inClauses = append(inClauses, fmt.Sprintf("%s IN (%s)", key, strings.Join(quoted, ", ")))
-	}
-	inFilterExpr := strings.Join(inClauses, " AND ")
-
-	fullReq := &qbtypes.QueryRangeRequest{
-		Start:       uint64(start),
-		End:         uint64(end),
-		RequestType: qbtypes.RequestTypeScalar,
-		CompositeQuery: qbtypes.CompositeQuery{
-			Queries: make([]qbtypes.QueryEnvelope, 0, len(tableListQuery.CompositeQuery.Queries)),
-		},
-	}
-
-	for _, envelope := range tableListQuery.CompositeQuery.Queries {
-		copied := envelope
-		if copied.Type == qbtypes.QueryTypeBuilder {
-			existingExpr := ""
-			if f := copied.GetFilter(); f != nil {
-				existingExpr = f.Expression
-			}
-			merged := mergeFilterExpressions(existingExpr, filterExpr)
-			merged = mergeFilterExpressions(merged, inFilterExpr)
-			copied.SetFilter(&qbtypes.Filter{Expression: merged})
-			copied.SetGroupBy(groupBy)
-		}
-		fullReq.CompositeQuery.Queries = append(fullReq.CompositeQuery.Queries, copied)
-	}
-
-	return fullReq
-}
-
-// parseFullQueryResponse extracts per-group metric values from the full
-// composite query response. Returns compositeKey -> (queryName -> value).
-// Each enabled query/formula produces its own ScalarData entry in Results,
-// so we iterate over all of them and merge metrics per composite key.
-func parseFullQueryResponse(
-	resp *qbtypes.QueryRangeResponse,
-	groupBy []qbtypes.GroupByKey,
-) map[string]map[string]float64 {
-	result := make(map[string]map[string]float64)
-	if resp == nil || len(resp.Data.Results) == 0 {
-		return result
-	}
-
-	for _, r := range resp.Data.Results {
-		sd, ok := r.(*qbtypes.ScalarData)
-		if !ok || sd == nil {
-			continue
-		}
-
-		groupColIndices := make(map[string]int)
-		aggCols := make(map[int]string) // col index -> query name
-		for i, col := range sd.Columns {
-			if col.Type == qbtypes.ColumnTypeGroup {
-				groupColIndices[col.Name] = i
-			}
-			if col.Type == qbtypes.ColumnTypeAggregation {
-				aggCols[i] = col.QueryName
-			}
-		}
-
-		for _, row := range sd.Data {
-			labels := make(map[string]string, len(groupBy))
-			for _, key := range groupBy {
-				if idx, ok := groupColIndices[key.Name]; ok && idx < len(row) {
-					labels[key.Name] = fmt.Sprintf("%v", row[idx])
-				}
-			}
-			compositeKey := compositeKeyFromLabels(labels, groupBy)
-
-			if result[compositeKey] == nil {
-				result[compositeKey] = make(map[string]float64)
-			}
-			for idx, queryName := range aggCols {
-				if idx < len(row) {
-					if v, ok := row[idx].(float64); ok {
-						result[compositeKey][queryName] = v
-					}
-				}
-			}
-		}
-	}
-	return result
-}

pkg/modules/inframonitoring/implinframonitoring/helpers_test.go

@@ -1,283 +0,0 @@
-package implinframonitoring
-
-import (
-	"testing"
-
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-)
-
-func groupByKey(name string) qbtypes.GroupByKey {
-	return qbtypes.GroupByKey{
-		TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: name},
-	}
-}
-
-func TestIsKeyInGroupByAttrs(t *testing.T) {
-	tests := []struct {
-		name          string
-		groupByAttrs  []qbtypes.GroupByKey
-		key           string
-		expectedFound bool
-	}{
-		{
-			name:          "key present in single-element list",
-			groupByAttrs:  []qbtypes.GroupByKey{groupByKey("host.name")},
-			key:           "host.name",
-			expectedFound: true,
-		},
-		{
-			name: "key present in multi-element list",
-			groupByAttrs: []qbtypes.GroupByKey{
-				groupByKey("host.name"),
-				groupByKey("os.type"),
-				groupByKey("k8s.cluster.name"),
-			},
-			key:           "os.type",
-			expectedFound: true,
-		},
-		{
-			name: "key at last position",
-			groupByAttrs: []qbtypes.GroupByKey{
-				groupByKey("host.name"),
-				groupByKey("os.type"),
-			},
-			key:           "os.type",
-			expectedFound: true,
-		},
-		{
-			name:          "key not in list",
-			groupByAttrs:  []qbtypes.GroupByKey{groupByKey("host.name")},
-			key:           "os.type",
-			expectedFound: false,
-		},
-		{
-			name:          "empty group by list",
-			groupByAttrs:  []qbtypes.GroupByKey{},
-			key:           "host.name",
-			expectedFound: false,
-		},
-		{
-			name:          "nil group by list",
-			groupByAttrs:  nil,
-			key:           "host.name",
-			expectedFound: false,
-		},
-		{
-			name:          "empty key string",
-			groupByAttrs:  []qbtypes.GroupByKey{groupByKey("host.name")},
-			key:           "",
-			expectedFound: false,
-		},
-		{
-			name:          "empty key matches empty-named group by key",
-			groupByAttrs:  []qbtypes.GroupByKey{groupByKey("")},
-			key:           "",
-			expectedFound: true,
-		},
-		{
-			name: "partial match does not count",
-			groupByAttrs: []qbtypes.GroupByKey{
-				groupByKey("host"),
-			},
-			key:           "host.name",
-			expectedFound: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := isKeyInGroupByAttrs(tt.groupByAttrs, tt.key)
-			if got != tt.expectedFound {
-				t.Errorf("isKeyInGroupByAttrs(%v, %q) = %v, want %v",
-					tt.groupByAttrs, tt.key, got, tt.expectedFound)
-			}
-		})
-	}
-}
-
-func TestMergeFilterExpressions(t *testing.T) {
-	tests := []struct {
-		name            string
-		queryFilterExpr string
-		reqFilterExpr   string
-		expected        string
-	}{
-		{
-			name:            "both non-empty",
-			queryFilterExpr: "cpu > 50",
-			reqFilterExpr:   "host.name = 'web-1'",
-			expected:        "(cpu > 50) AND (host.name = 'web-1')",
-		},
-		{
-			name:            "query empty, req non-empty",
-			queryFilterExpr: "",
-			reqFilterExpr:   "host.name = 'web-1'",
-			expected:        "host.name = 'web-1'",
-		},
-		{
-			name:            "query non-empty, req empty",
-			queryFilterExpr: "cpu > 50",
-			reqFilterExpr:   "",
-			expected:        "cpu > 50",
-		},
-		{
-			name:            "both empty",
-			queryFilterExpr: "",
-			reqFilterExpr:   "",
-			expected:        "",
-		},
-		{
-			name:            "whitespace-only query treated as empty",
-			queryFilterExpr: "   ",
-			reqFilterExpr:   "host.name = 'web-1'",
-			expected:        "host.name = 'web-1'",
-		},
-		{
-			name:            "whitespace-only req treated as empty",
-			queryFilterExpr: "cpu > 50",
-			reqFilterExpr:   "   ",
-			expected:        "cpu > 50",
-		},
-		{
-			name:            "both whitespace-only",
-			queryFilterExpr: "  ",
-			reqFilterExpr:   "  ",
-			expected:        "",
-		},
-		{
-			name:            "leading/trailing whitespace trimmed before merge",
-			queryFilterExpr: "  cpu > 50  ",
-			reqFilterExpr:   "  mem < 80  ",
-			expected:        "(cpu > 50) AND (mem < 80)",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := mergeFilterExpressions(tt.queryFilterExpr, tt.reqFilterExpr)
-			if got != tt.expected {
-				t.Errorf("mergeFilterExpressions(%q, %q) = %q, want %q",
-					tt.queryFilterExpr, tt.reqFilterExpr, got, tt.expected)
-			}
-		})
-	}
-}
-
-func TestCompositeKeyFromList(t *testing.T) {
-	tests := []struct {
-		name     string
-		parts    []string
-		expected string
-	}{
-		{
-			name:     "single part",
-			parts:    []string{"web-1"},
-			expected: "web-1",
-		},
-		{
-			name:     "multiple parts joined with null separator",
-			parts:    []string{"web-1", "linux", "us-east"},
-			expected: "web-1\x00linux\x00us-east",
-		},
-		{
-			name:     "empty slice returns empty string",
-			parts:    []string{},
-			expected: "",
-		},
-		{
-			name:     "nil slice returns empty string",
-			parts:    nil,
-			expected: "",
-		},
-		{
-			name:     "parts with empty strings",
-			parts:    []string{"web-1", "", "us-east"},
-			expected: "web-1\x00\x00us-east",
-		},
-		{
-			name:     "all empty strings",
-			parts:    []string{"", ""},
-			expected: "\x00",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := compositeKeyFromList(tt.parts)
-			if got != tt.expected {
-				t.Errorf("compositeKeyFromList(%v) = %q, want %q",
-					tt.parts, got, tt.expected)
-			}
-		})
-	}
-}
-
-func TestCompositeKeyFromLabels(t *testing.T) {
-	tests := []struct {
-		name     string
-		labels   map[string]string
-		groupBy  []qbtypes.GroupByKey
-		expected string
-	}{
-		{
-			name:     "single group-by key",
-			labels:   map[string]string{"host.name": "web-1"},
-			groupBy:  []qbtypes.GroupByKey{groupByKey("host.name")},
-			expected: "web-1",
-		},
-		{
-			name: "multiple group-by keys joined with null separator",
-			labels: map[string]string{
-				"host.name": "web-1",
-				"os.type":   "linux",
-			},
-			groupBy:  []qbtypes.GroupByKey{groupByKey("host.name"), groupByKey("os.type")},
-			expected: "web-1\x00linux",
-		},
-		{
-			name:     "missing label yields empty segment",
-			labels:   map[string]string{"host.name": "web-1"},
-			groupBy:  []qbtypes.GroupByKey{groupByKey("host.name"), groupByKey("os.type")},
-			expected: "web-1\x00",
-		},
-		{
-			name:     "empty labels map",
-			labels:   map[string]string{},
-			groupBy:  []qbtypes.GroupByKey{groupByKey("host.name")},
-			expected: "",
-		},
-		{
-			name:     "empty group-by slice",
-			labels:   map[string]string{"host.name": "web-1"},
-			groupBy:  []qbtypes.GroupByKey{},
-			expected: "",
-		},
-		{
-			name:     "nil labels map",
-			labels:   nil,
-			groupBy:  []qbtypes.GroupByKey{groupByKey("host.name")},
-			expected: "",
-		},
-		{
-			name: "order matches group-by order, not map iteration order",
-			labels: map[string]string{
-				"z": "last",
-				"a": "first",
-				"m": "middle",
-			},
-			groupBy:  []qbtypes.GroupByKey{groupByKey("a"), groupByKey("m"), groupByKey("z")},
-			expected: "first\x00middle\x00last",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := compositeKeyFromLabels(tt.labels, tt.groupBy)
-			if got != tt.expected {
-				t.Errorf("compositeKeyFromLabels(%v, %v) = %q, want %q",
-					tt.labels, tt.groupBy, got, tt.expected)
-			}
-		})
-	}
-}

pkg/modules/inframonitoring/implinframonitoring/hosts.go

@@ -1,494 +0,0 @@
-package implinframonitoring
-
-import (
-	"context"
-	"fmt"
-	"slices"
-	"strings"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
-	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
-	"github.com/SigNoz/signoz/pkg/types/metrictypes"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/huandu/go-sqlbuilder"
-)
-
-const (
-	hostNameAttrKey = "host.name"
-)
-
-// Helper group-by key used across all queries.
-var hostNameGroupByKey = qbtypes.GroupByKey{
-	TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-		Name:          hostNameAttrKey,
-		FieldContext:  telemetrytypes.FieldContextResource,
-		FieldDataType: telemetrytypes.FieldDataTypeString,
-	},
-}
-
-var hostsTableMetricNamesList = []string{
-	"system.cpu.time",
-	"system.memory.usage",
-	"system.cpu.load_average.15m",
-	"system.filesystem.usage",
-}
-
-var hostAttrKeysForMetadata = []string{
-	"os.type",
-}
-
-// orderByToHostsQueryNames maps the orderBy column to the query/formula names
-// from HostsTableListQuery used for ranking host groups.
-var orderByToHostsQueryNames = map[string][]string{
-	inframonitoringtypes.HostsOrderByCPU:       {"A", "B", "F1"},
-	inframonitoringtypes.HostsOrderByMemory:    {"C", "D", "F2"},
-	inframonitoringtypes.HostsOrderByWait:      {"E", "F", "F3"},
-	inframonitoringtypes.HostsOrderByDiskUsage: {"H", "I", "F4"},
-	inframonitoringtypes.HostsOrderByLoad15:    {"G"},
-}
-
-func (m *module) newHostsTableListQuery() *qbtypes.QueryRangeRequest {
-	return &qbtypes.QueryRangeRequest{
-		RequestType: qbtypes.RequestTypeScalar,
-		CompositeQuery: qbtypes.CompositeQuery{
-			Queries: []qbtypes.QueryEnvelope{
-				// Query A: CPU usage logic (non-idle)
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "A",
-						Signal: telemetrytypes.SignalMetrics,
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.cpu.time",
-								Temporality:      metrictypes.Cumulative,
-								TimeAggregation:  metrictypes.TimeAggregationRate,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						Filter: &qbtypes.Filter{
-							Expression: "state != 'idle'",
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: true,
-					},
-				},
-				// Query B: CPU usage (all states)
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "B",
-						Signal: telemetrytypes.SignalMetrics,
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.cpu.time",
-								Temporality:      metrictypes.Cumulative,
-								TimeAggregation:  metrictypes.TimeAggregationRate,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: true,
-					},
-				},
-				// Formula F1: CPU Usage (%)
-				{
-					Type: qbtypes.QueryTypeFormula,
-					Spec: qbtypes.QueryBuilderFormula{
-						Name:       "F1",
-						Expression: "A/B",
-						Legend:     "CPU Usage (%)",
-						Disabled:   false,
-					},
-				},
-				// Query C: Memory usage (state = used)
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "C",
-						Signal: telemetrytypes.SignalMetrics,
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.memory.usage",
-								Temporality:      metrictypes.Cumulative,
-								TimeAggregation:  metrictypes.TimeAggregationAvg,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						Filter: &qbtypes.Filter{
-							Expression: "state = 'used'",
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: true,
-					},
-				},
-				// Query D: Memory usage (all states)
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "D",
-						Signal: telemetrytypes.SignalMetrics,
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.memory.usage",
-								Temporality:      metrictypes.Cumulative,
-								TimeAggregation:  metrictypes.TimeAggregationAvg,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: true,
-					},
-				},
-				// Formula F2: Memory Usage (%)
-				{
-					Type: qbtypes.QueryTypeFormula,
-					Spec: qbtypes.QueryBuilderFormula{
-						Name:       "F2",
-						Expression: "C/D",
-						Legend:     "Memory Usage (%)",
-						Disabled:   false,
-					},
-				},
-				// Query E: CPU Wait time (state = wait)
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "E",
-						Signal: telemetrytypes.SignalMetrics,
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.cpu.time",
-								Temporality:      metrictypes.Cumulative,
-								TimeAggregation:  metrictypes.TimeAggregationRate,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						Filter: &qbtypes.Filter{
-							Expression: "state = 'wait'",
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: true,
-					},
-				},
-				// Query F: CPU time (all states)
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "F",
-						Signal: telemetrytypes.SignalMetrics,
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.cpu.time",
-								Temporality:      metrictypes.Cumulative,
-								TimeAggregation:  metrictypes.TimeAggregationRate,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: true,
-					},
-				},
-				// Formula F3: CPU Wait Time (%)
-				{
-					Type: qbtypes.QueryTypeFormula,
-					Spec: qbtypes.QueryBuilderFormula{
-						Name:       "F3",
-						Expression: "E/F",
-						Legend:     "CPU Wait Time (%)",
-						Disabled:   false,
-					},
-				},
-				// Query G: Load15
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "G",
-						Signal: telemetrytypes.SignalMetrics,
-						Legend: "CPU Load Average (15m)",
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.cpu.load_average.15m",
-								Temporality:      metrictypes.Unspecified,
-								TimeAggregation:  metrictypes.TimeAggregationAvg,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: false,
-					},
-				},
-				// Query H: Filesystem Usage (state = used)
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "H",
-						Signal: telemetrytypes.SignalMetrics,
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.filesystem.usage",
-								Temporality:      metrictypes.Cumulative,
-								TimeAggregation:  metrictypes.TimeAggregationAvg,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						Filter: &qbtypes.Filter{
-							Expression: "state = 'used'",
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: true,
-					},
-				},
-				// Query I: Filesystem Usage (all states)
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "I",
-						Signal: telemetrytypes.SignalMetrics,
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.filesystem.usage",
-								Temporality:      metrictypes.Cumulative,
-								TimeAggregation:  metrictypes.TimeAggregationAvg,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: true,
-					},
-				},
-				// Formula F4: Disk Usage (%)
-				{
-					Type: qbtypes.QueryTypeFormula,
-					Spec: qbtypes.QueryBuilderFormula{
-						Name:       "F4",
-						Expression: "H/I",
-						Legend:     "Disk Usage (%)",
-						Disabled:   false,
-					},
-				},
-			},
-		},
-	}
-}
-
-// getTopHostGroups runs a ranking query for the ordering metric, sorts the
-// results, paginates, and backfills from metadataMap when the page extends
-// past the metric-ranked groups.
-func (m *module) getTopHostGroups(
-	ctx context.Context,
-	orgID valuer.UUID,
-	req *inframonitoringtypes.HostsListRequest,
-	metadataMap map[string]map[string]string,
-) ([]map[string]string, error) {
-	orderByKey := req.OrderBy.Key.Name
-	queryNamesForOrderBy := orderByToHostsQueryNames[orderByKey]
-	// The last entry is the formula/query whose value we sort by.
-	rankingQueryName := queryNamesForOrderBy[len(queryNamesForOrderBy)-1]
-
-	topReq := &qbtypes.QueryRangeRequest{
-		Start:       uint64(req.Start),
-		End:         uint64(req.End),
-		RequestType: qbtypes.RequestTypeScalar,
-		CompositeQuery: qbtypes.CompositeQuery{
-			Queries: make([]qbtypes.QueryEnvelope, 0, len(queryNamesForOrderBy)),
-		},
-	}
-
-	for _, envelope := range m.newHostsTableListQuery().CompositeQuery.Queries {
-		if !slices.Contains(queryNamesForOrderBy, envelope.GetQueryName()) {
-			continue
-		}
-		copied := envelope
-		if copied.Type == qbtypes.QueryTypeBuilder {
-			existingExpr := ""
-			if f := copied.GetFilter(); f != nil {
-				existingExpr = f.Expression
-			}
-			reqFilterExpr := ""
-			if req.Filter != nil {
-				reqFilterExpr = req.Filter.Expression
-			}
-			merged := mergeFilterExpressions(existingExpr, reqFilterExpr)
-			copied.SetFilter(&qbtypes.Filter{Expression: merged})
-			copied.SetGroupBy(req.GroupBy)
-		}
-		topReq.CompositeQuery.Queries = append(topReq.CompositeQuery.Queries, copied)
-	}
-
-	resp, err := m.querier.QueryRange(ctx, orgID, topReq)
-	if err != nil {
-		return nil, err
-	}
-
-	allMetricGroups := parseAndSortGroups(resp, rankingQueryName, req.GroupBy, req.OrderBy.Direction)
-	return paginateWithBackfill(allMetricGroups, metadataMap, req.GroupBy, req.Offset, req.Limit), nil
-}
-
-// applyHostsActiveStatusFilter modifies req.Filter.Expression to include an IN/NOT IN
-// clause based on FilterByStatus and the set of active hosts.
-// Returns true if the caller should short-circuit with an empty result (eg. ACTIVE
-// requested but no hosts are active).
-func (m *module) applyHostsActiveStatusFilter(req *inframonitoringtypes.HostsListRequest, activeHostsMap map[string]bool) (shouldShortCircuit bool) {
-	if req.Filter == nil || (req.Filter.FilterByStatus != inframonitoringtypes.HostStatusActive && req.Filter.FilterByStatus != inframonitoringtypes.HostStatusInactive) {
-		return false
-	}
-
-	activeHosts := make([]string, 0, len(activeHostsMap))
-	for host := range activeHostsMap {
-		activeHosts = append(activeHosts, fmt.Sprintf("'%s'", host))
-	}
-
-	if len(activeHosts) == 0 {
-		return req.Filter.FilterByStatus == inframonitoringtypes.HostStatusActive
-	}
-
-	op := "IN"
-	if req.Filter.FilterByStatus == inframonitoringtypes.HostStatusInactive {
-		op = "NOT IN"
-	}
-	statusClause := fmt.Sprintf("%s %s (%s)", hostNameAttrKey, op, strings.Join(activeHosts, ", "))
-	req.Filter.Expression = mergeFilterExpressions(req.Filter.Expression, statusClause)
-	return false
-}
-
-func (m *module) getHostsTableMetadata(ctx context.Context, req *inframonitoringtypes.HostsListRequest) (map[string]map[string]string, error) {
-	var nonGroupByAttrs []string
-	for _, key := range hostAttrKeysForMetadata {
-		if !isKeyInGroupByAttrs(req.GroupBy, key) {
-			nonGroupByAttrs = append(nonGroupByAttrs, key)
-		}
-	}
-	var filter *qbtypes.Filter
-	if req.Filter != nil {
-		filter = &req.Filter.Filter
-	}
-	metadataMap, err := m.getMetadata(ctx, hostsTableMetricNamesList, req.GroupBy, nonGroupByAttrs, filter, req.Start, req.End)
-	if err != nil {
-		return nil, err
-	}
-	return metadataMap, nil
-}
-
-// buildHostRecords constructs the final list of HostRecords for a page.
-// Groups that had no metric data get default values of -1.
-func (m *module) buildHostRecords(
-	resp *qbtypes.QueryRangeResponse,
-	pageGroups []map[string]string,
-	groupBy []qbtypes.GroupByKey,
-	metadataMap map[string]map[string]string,
-	activeHostsMap map[string]bool,
-) []inframonitoringtypes.HostRecord {
-	metricsMap := parseFullQueryResponse(resp, groupBy)
-
-	records := make([]inframonitoringtypes.HostRecord, 0, len(pageGroups))
-	for _, labels := range pageGroups {
-		compositeKey := compositeKeyFromLabels(labels, groupBy)
-		hostName := labels[hostNameAttrKey]
-
-		activeStatus := inframonitoringtypes.HostStatusNone
-		if hostName != "" {
-			if activeHostsMap[hostName] {
-				activeStatus = inframonitoringtypes.HostStatusActive
-			} else {
-				activeStatus = inframonitoringtypes.HostStatusInactive
-			}
-		}
-
-		record := inframonitoringtypes.HostRecord{
-			HostName:  hostName,
-			Status:    activeStatus,
-			CPU:       -1,
-			Memory:    -1,
-			Wait:      -1,
-			Load15:    -1,
-			DiskUsage: -1,
-			Meta:      map[string]interface{}{},
-		}
-
-		if metrics, ok := metricsMap[compositeKey]; ok {
-			if v, exists := metrics["F1"]; exists {
-				record.CPU = v
-			}
-			if v, exists := metrics["F2"]; exists {
-				record.Memory = v
-			}
-			if v, exists := metrics["F3"]; exists {
-				record.Wait = v
-			}
-			if v, exists := metrics["F4"]; exists {
-				record.DiskUsage = v
-			}
-			if v, exists := metrics["G"]; exists {
-				record.Load15 = v
-			}
-		}
-
-		if attrs, ok := metadataMap[compositeKey]; ok {
-			for k, v := range attrs {
-				record.Meta[k] = v
-			}
-		}
-
-		records = append(records, record)
-	}
-	return records
-}
-
-// getActiveHosts returns a set of host names that have reported metrics recently (since sinceUnixMilli).
-// It queries distributed_metadata for hosts where last_reported_unix_milli >= sinceUnixMilli.
-// TODO(nikhilmantri0902): This method does not return active hosts numbers based on custom grouping by. So
-// if we have a different group by key than host.name in the API, then this method's response, will be useless technically, because
-// with a group-by different from host.name, we should show count of active-inactive hosts in that group.
-// We should have a way to determine active groups based on the group by keys in the request.
-func (m *module) getActiveHosts(ctx context.Context, metricNames []string, hostNameAttr string) (map[string]bool, error) {
-	sinceUnixMilli := time.Now().Add(-10 * time.Minute).UTC().UnixMilli()
-
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Distinct()
-	sb.Select("attr_string_value")
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.AttributesMetadataTableName))
-	sb.Where(
-		sb.In("metric_name", sqlbuilder.List(metricNames)),
-		sb.E("attr_name", hostNameAttr),
-		sb.NE("attr_string_value", ""),
-		sb.GE("last_reported_unix_milli", sinceUnixMilli),
-	)
-
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-
-	rows, err := m.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	activeHosts := make(map[string]bool)
-	for rows.Next() {
-		var hostName string
-		if err := rows.Scan(&hostName); err != nil {
-			return nil, err
-		}
-		if hostName != "" {
-			activeHosts[hostName] = true
-		}
-	}
-
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-
-	return activeHosts, nil
-}

pkg/modules/inframonitoring/implinframonitoring/module.go

@@ -1,145 +0,0 @@
-package implinframonitoring
-
-import (
-	"context"
-	"log/slog"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
-	"github.com/SigNoz/signoz/pkg/querier"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type module struct {
-	telemetryStore         telemetrystore.TelemetryStore
-	telemetryMetadataStore telemetrytypes.MetadataStore
-	querier                querier.Querier
-	fieldMapper            qbtypes.FieldMapper
-	condBuilder            qbtypes.ConditionBuilder
-	logger                 *slog.Logger
-	config                 inframonitoring.Config
-}
-
-// NewModule constructs the inframonitoring module with the provided dependencies.
-func NewModule(
-	telemetryStore telemetrystore.TelemetryStore,
-	telemetryMetadataStore telemetrytypes.MetadataStore,
-	querier querier.Querier,
-	providerSettings factory.ProviderSettings,
-	cfg inframonitoring.Config,
-) inframonitoring.Module {
-	fieldMapper := telemetrymetrics.NewFieldMapper()
-	condBuilder := telemetrymetrics.NewConditionBuilder(fieldMapper)
-	return &module{
-		telemetryStore:         telemetryStore,
-		telemetryMetadataStore: telemetryMetadataStore,
-		querier:                querier,
-		fieldMapper:            fieldMapper,
-		condBuilder:            condBuilder,
-		logger:                 providerSettings.Logger,
-		config:                 cfg,
-	}
-}
-
-func (m *module) HostsList(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.HostsListRequest) (*inframonitoringtypes.HostsListResponse, error) {
-	if err := req.Validate(); err != nil {
-		return nil, err
-	}
-
-	resp := &inframonitoringtypes.HostsListResponse{}
-
-	// default to cpu order by
-	if req.OrderBy == nil {
-		req.OrderBy = &qbtypes.OrderBy{
-			Key: qbtypes.OrderByKey{
-				TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-					Name: "cpu",
-				},
-			},
-			Direction: qbtypes.OrderDirectionDesc,
-		}
-	}
-
-	// default to host name group by
-	if len(req.GroupBy) == 0 {
-		req.GroupBy = []qbtypes.GroupByKey{hostNameGroupByKey}
-		resp.Type = inframonitoringtypes.ResponseTypeList
-	} else {
-		resp.Type = inframonitoringtypes.ResponseTypeGroupedList
-	}
-
-	// 1. Check which required metrics exist and get earliest retention time.
-	// If any required metric is missing, return early with the list of missing metrics.
-	// 2. If metrics exist but req.End is before the earliest reported time, convey retention boundary.
-	missingMetrics, minFirstReportedUnixMilli, err := m.getMetricsExistenceAndEarliestTime(ctx, hostsTableMetricNamesList)
-	if err != nil {
-		return nil, err
-	}
-	if len(missingMetrics) > 0 {
-		resp.RequiredMetricsCheck = inframonitoringtypes.RequiredMetricsCheck{MissingMetrics: missingMetrics}
-		resp.Records = []inframonitoringtypes.HostRecord{}
-		resp.Total = 0
-		return resp, nil
-	}
-	if req.End < int64(minFirstReportedUnixMilli) {
-		resp.EndTimeBeforeRetention = true
-		resp.Records = []inframonitoringtypes.HostRecord{}
-		resp.Total = 0
-		return resp, nil
-	}
-
-	// TODO: replace this separate ClickHouse query with a sub-query inside the main query builder query
-	// once QB supports sub-queries. Tracked in PR #10805 review.
-	// Determine active hosts: those with metrics reported in the last 10 minutes.
-	activeHostsMap, err := m.getActiveHosts(ctx, hostsTableMetricNamesList, hostNameAttrKey)
-	if err != nil {
-		return nil, err
-	}
-
-	// this check below modifies req.Filter by adding `AND active hosts filter` if req.FilterByStatus is set.
-	if m.applyHostsActiveStatusFilter(req, activeHostsMap) {
-		resp.Records = []inframonitoringtypes.HostRecord{}
-		resp.Total = 0
-		return resp, nil
-	}
-
-	metadataMap, err := m.getHostsTableMetadata(ctx, req)
-	if err != nil {
-		return nil, err
-	}
-	if metadataMap == nil {
-		metadataMap = make(map[string]map[string]string)
-	}
-
-	resp.Total = len(metadataMap)
-
-	pageGroups, err := m.getTopHostGroups(ctx, orgID, req, metadataMap)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(pageGroups) == 0 {
-		resp.Records = []inframonitoringtypes.HostRecord{}
-		return resp, nil
-	}
-
-	hostsFilterExpr := ""
-	if req.Filter != nil {
-		hostsFilterExpr = req.Filter.Expression
-	}
-	fullQueryReq := buildFullQueryRequest(req.Start, req.End, hostsFilterExpr, req.GroupBy, pageGroups, m.newHostsTableListQuery())
-	queryResp, err := m.querier.QueryRange(ctx, orgID, fullQueryReq)
-	if err != nil {
-		return nil, err
-	}
-
-	resp.Records = m.buildHostRecords(queryResp, pageGroups, req.GroupBy, metadataMap, activeHostsMap)
-	resp.Warning = queryResp.Warning
-
-	return resp, nil
-}

pkg/modules/inframonitoring/inframonitoring.go

@@ -1,17 +0,0 @@
-package inframonitoring
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type Handler interface {
-	HostsList(http.ResponseWriter, *http.Request)
-}
-
-type Module interface {
-	HostsList(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.HostsListRequest) (*inframonitoringtypes.HostsListResponse, error)
-}

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

@@ -905,7 +905,7 @@ func (r *ClickHouseReader) GetWaterfallSpansForTraceWithMetadataCache(ctx contex
 		return nil, err
 	}
 
-	if time.Since(time.UnixMilli(int64(cachedTraceData.EndTime))) < r.fluxIntervalForTraceDetail {
+	if time.Since(time.Unix(0, int64(cachedTraceData.EndTime))) < r.fluxIntervalForTraceDetail {
 		r.logger.Info("the trace end time falls under the flux interval, skipping getWaterfallSpansForTraceWithMetadata cache", "traceID", traceID)
 		return nil, errors.Errorf("the trace end time falls under the flux interval, skipping getWaterfallSpansForTraceWithMetadata cache, traceID: %s", traceID)
 	}
@@ -1138,7 +1138,7 @@ func (r *ClickHouseReader) GetFlamegraphSpansForTraceCache(ctx context.Context,
 		return nil, err
 	}
 
-	if time.Since(time.UnixMilli(int64(cachedTraceData.EndTime))) < r.fluxIntervalForTraceDetail {
+	if time.Since(time.Unix(0, int64(cachedTraceData.EndTime))) < r.fluxIntervalForTraceDetail {
 		r.logger.Info("the trace end time falls under the flux interval, skipping getFlamegraphSpansForTrace cache", "traceID", traceID)
 		return nil, errors.Errorf("the trace end time falls under the flux interval, skipping getFlamegraphSpansForTrace cache, traceID: %s", traceID)
 	}

pkg/query-service/app/http_handler.go

@@ -27,7 +27,6 @@ import (
 
 	"github.com/prometheus/prometheus/promql"
 
-	"github.com/SigNoz/signoz/pkg/alertmanager"
 	errorsV2 "github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	"github.com/SigNoz/signoz/pkg/http/render"
@@ -140,8 +139,6 @@ type APIHandler struct {
 
 	pvcsRepo *inframetrics.PvcsRepo
 
-	AlertmanagerAPI *alertmanager.API
-
 	LicensingAPI licensing.API
 
 	QueryParserAPI *queryparser.API
@@ -168,8 +165,6 @@ type APIHandlerOpts struct {
 	// Flux Interval
 	FluxInterval time.Duration
 
-	AlertmanagerAPI *alertmanager.API
-
 	LicensingAPI licensing.API
 
 	QueryParserAPI *queryparser.API
@@ -230,7 +225,6 @@ func NewAPIHandler(opts APIHandlerOpts, config signoz.Config) (*APIHandler, erro
 		statefulsetsRepo:              statefulsetsRepo,
 		jobsRepo:                      jobsRepo,
 		pvcsRepo:                      pvcsRepo,
-		AlertmanagerAPI:               opts.AlertmanagerAPI,
 		LicensingAPI:                  opts.LicensingAPI,
 		Signoz:                        opts.Signoz,
 		QueryParserAPI:                opts.QueryParserAPI,
@@ -502,21 +496,6 @@ func (aH *APIHandler) Respond(w http.ResponseWriter, data interface{}) {
 func (aH *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	router.HandleFunc("/api/v1/query_range", am.ViewAccess(aH.queryRangeMetrics)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/query", am.ViewAccess(aH.queryMetrics)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/channels", am.ViewAccess(aH.AlertmanagerAPI.ListChannels)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/channels/{id}", am.ViewAccess(aH.AlertmanagerAPI.GetChannelByID)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/channels/{id}", am.AdminAccess(aH.AlertmanagerAPI.UpdateChannelByID)).Methods(http.MethodPut)
-	router.HandleFunc("/api/v1/channels/{id}", am.AdminAccess(aH.AlertmanagerAPI.DeleteChannelByID)).Methods(http.MethodDelete)
-	router.HandleFunc("/api/v1/channels", am.EditAccess(aH.AlertmanagerAPI.CreateChannel)).Methods(http.MethodPost)
-	router.HandleFunc("/api/v1/testChannel", am.EditAccess(aH.AlertmanagerAPI.TestReceiver)).Methods(http.MethodPost)
-
-	router.HandleFunc("/api/v1/route_policies", am.ViewAccess(aH.AlertmanagerAPI.GetAllRoutePolicies)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/route_policies/{id}", am.ViewAccess(aH.AlertmanagerAPI.GetRoutePolicyByID)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/route_policies", am.AdminAccess(aH.AlertmanagerAPI.CreateRoutePolicy)).Methods(http.MethodPost)
-	router.HandleFunc("/api/v1/route_policies/{id}", am.AdminAccess(aH.AlertmanagerAPI.DeleteRoutePolicyByID)).Methods(http.MethodDelete)
-	router.HandleFunc("/api/v1/route_policies/{id}", am.AdminAccess(aH.AlertmanagerAPI.UpdateRoutePolicy)).Methods(http.MethodPut)
-
-	router.HandleFunc("/api/v1/alerts", am.ViewAccess(aH.AlertmanagerAPI.GetAlerts)).Methods(http.MethodGet)
-
 	router.HandleFunc("/api/v1/rules", am.ViewAccess(aH.listRules)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/rules/{id}", am.ViewAccess(aH.getRule)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/rules", am.EditAccess(aH.createRule)).Methods(http.MethodPost)

pkg/query-service/app/server.go

@@ -136,7 +136,6 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 		CloudIntegrationsController:   cloudIntegrationsController,
 		LogsParsingPipelineController: logParsingPipelineController,
 		FluxInterval:                  config.Querier.FluxInterval,
-		AlertmanagerAPI:               alertmanager.NewAPI(signoz.Alertmanager),
 		LicensingAPI:                  nooplicensing.NewLicenseAPI(),
 		Signoz:                        signoz,
 		QueryParserAPI:                queryparser.NewAPI(signoz.Instrumentation.ToProviderSettings(), signoz.QueryParser),

pkg/signoz/config.go

@@ -23,7 +23,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/identn"
 	"github.com/SigNoz/signoz/pkg/instrumentation"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/user"
@@ -115,9 +114,6 @@ type Config struct {
 	// MetricsExplorer config
 	MetricsExplorer metricsexplorer.Config `mapstructure:"metricsexplorer"`
 
-	// InfraMonitoring config
-	InfraMonitoring inframonitoring.Config `mapstructure:"inframonitoring"`
-
 	// Flagger config
 	Flagger flagger.Config `mapstructure:"flagger"`
 
@@ -161,7 +157,6 @@ func NewConfig(ctx context.Context, logger *slog.Logger, resolverConfig config.R
 		gateway.NewConfigFactory(),
 		tokenizer.NewConfigFactory(),
 		metricsexplorer.NewConfigFactory(),
-		inframonitoring.NewConfigFactory(),
 		flagger.NewConfigFactory(),
 		user.NewConfigFactory(),
 		identn.NewConfigFactory(),

pkg/signoz/handler.go

@@ -1,6 +1,8 @@
 package signoz
 
 import (
+	"github.com/SigNoz/signoz/pkg/alertmanager"
+	"github.com/SigNoz/signoz/pkg/alertmanager/signozalertmanager"
 	"github.com/SigNoz/signoz/pkg/analytics"
 	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/authz/signozauthzapi"
@@ -18,8 +20,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/fields"
 	"github.com/SigNoz/signoz/pkg/modules/fields/implfields"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring/implinframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer/implmetricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/quickfilter"
@@ -53,7 +53,6 @@ type Handlers struct {
 	SpanPercentile          spanpercentile.Handler
 	Services                services.Handler
 	MetricsExplorer         metricsexplorer.Handler
-	InfraMonitoring         inframonitoring.Handler
 	Global                  global.Handler
 	FlaggerHandler          flagger.Handler
 	GatewayHandler          gateway.Handler
@@ -65,6 +64,7 @@ type Handlers struct {
 	RegistryHandler         factory.Handler
 	CloudIntegrationHandler cloudintegration.Handler
 	RuleStateHistory        rulestatehistory.Handler
+	AlertmanagerHandler     alertmanager.Handler
 }
 
 func NewHandlers(
@@ -80,6 +80,7 @@ func NewHandlers(
 	authz authz.AuthZ,
 	zeusService zeus.Zeus,
 	registryHandler factory.Handler,
+	alertmanagerService alertmanager.Alertmanager,
 ) Handlers {
 	return Handlers{
 		SavedView:               implsavedview.NewHandler(modules.SavedView),
@@ -90,7 +91,6 @@ func NewHandlers(
 		RawDataExport:           implrawdataexport.NewHandler(modules.RawDataExport),
 		Services:                implservices.NewHandler(modules.Services),
 		MetricsExplorer:         implmetricsexplorer.NewHandler(modules.MetricsExplorer),
-		InfraMonitoring:         implinframonitoring.NewHandler(modules.InfraMonitoring),
 		SpanPercentile:          implspanpercentile.NewHandler(modules.SpanPercentile),
 		Global:                  signozglobal.NewHandler(global),
 		FlaggerHandler:          flagger.NewHandler(flaggerService),
@@ -103,5 +103,6 @@ func NewHandlers(
 		RegistryHandler:         registryHandler,
 		RuleStateHistory:        implrulestatehistory.NewHandler(modules.RuleStateHistory),
 		CloudIntegrationHandler: implcloudintegration.NewHandler(modules.CloudIntegration),
+		AlertmanagerHandler:     signozalertmanager.NewHandler(alertmanagerService),
 	}
 }

pkg/signoz/handler_test.go

@@ -56,7 +56,7 @@ func TestNewHandlers(t *testing.T) {
 
 	querierHandler := querier.NewHandler(providerSettings, nil, nil)
 	registryHandler := factory.NewHandler(nil)
-	handlers := NewHandlers(modules, providerSettings, nil, querierHandler, nil, nil, nil, nil, nil, nil, nil, registryHandler)
+	handlers := NewHandlers(modules, providerSettings, nil, querierHandler, nil, nil, nil, nil, nil, nil, nil, registryHandler, alertmanager)
 	reflectVal := reflect.ValueOf(handlers)
 	for i := 0; i < reflectVal.NumField(); i++ {
 		f := reflectVal.Field(i)

pkg/signoz/module.go

@@ -14,8 +14,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/authdomain/implauthdomain"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring/implinframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer/implmetricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
@@ -71,7 +69,6 @@ type Modules struct {
 	Services         services.Module
 	SpanPercentile   spanpercentile.Module
 	MetricsExplorer  metricsexplorer.Module
-	InfraMonitoring  inframonitoring.Module
 	Promote          promote.Module
 	ServiceAccount   serviceaccount.Module
 	CloudIntegration cloudintegration.Module
@@ -122,7 +119,6 @@ func NewModules(
 		SpanPercentile:   implspanpercentile.NewModule(querier, providerSettings),
 		Services:         implservices.NewModule(querier, telemetryStore),
 		MetricsExplorer:  implmetricsexplorer.NewModule(telemetryStore, telemetryMetadataStore, cache, ruleStore, dashboard, providerSettings, config.MetricsExplorer),
-		InfraMonitoring:  implinframonitoring.NewModule(telemetryStore, telemetryMetadataStore, querier, providerSettings, config.InfraMonitoring),
 		Promote:          implpromote.NewModule(telemetryMetadataStore, telemetryStore),
 		ServiceAccount:   serviceAccount,
 		RuleStateHistory: implrulestatehistory.NewModule(implrulestatehistory.NewStore(telemetryStore, telemetryMetadataStore, providerSettings.Logger)),

pkg/signoz/openapi.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"reflect"
 
+	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/apiserver"
 	"github.com/SigNoz/signoz/pkg/apiserver/signozapiserver"
 	"github.com/SigNoz/signoz/pkg/authz"
@@ -21,7 +22,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/fields"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/promote"
@@ -60,7 +60,6 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ dashboard.Module }{},
 		struct{ dashboard.Handler }{},
 		struct{ metricsexplorer.Handler }{},
-		struct{ inframonitoring.Handler }{},
 		struct{ gateway.Handler }{},
 		struct{ fields.Handler }{},
 		struct{ authz.Handler }{},
@@ -71,6 +70,7 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ factory.Handler }{},
 		struct{ cloudintegration.Handler }{},
 		struct{ rulestatehistory.Handler }{},
+		struct{ alertmanager.Handler }{},
 	).New(ctx, instrumentation.ToProviderSettings(), apiserver.Config{})
 	if err != nil {
 		return nil, err

pkg/signoz/provider.go

@@ -278,7 +278,6 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			modules.Dashboard,
 			handlers.Dashboard,
 			handlers.MetricsExplorer,
-			handlers.InfraMonitoring,
 			handlers.GatewayHandler,
 			handlers.Fields,
 			handlers.AuthzHandler,
@@ -289,6 +288,7 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			handlers.RegistryHandler,
 			handlers.CloudIntegrationHandler,
 			handlers.RuleStateHistory,
+			handlers.AlertmanagerHandler,
 		),
 	)
 }

pkg/signoz/signoz.go

@@ -500,7 +500,7 @@ func New(
 
 	// Initialize all handlers for the modules
 	registryHandler := factory.NewHandler(registry)
-	handlers := NewHandlers(modules, providerSettings, analytics, querierHandler, licensing, global, flagger, gateway, telemetryMetadataStore, authz, zeus, registryHandler)
+	handlers := NewHandlers(modules, providerSettings, analytics, querierHandler, licensing, global, flagger, gateway, telemetryMetadataStore, authz, zeus, registryHandler, alertmanager)
 
 	// Initialize the API server (after registry so it can access service health)
 	apiserverInstance, err := factory.NewProviderFromNamedMap(

pkg/types/alertmanagertypes/channel.go

@@ -34,10 +34,10 @@ type Channel struct {
 
 	types.Identifiable
 	types.TimeAuditable
-	Name  string `json:"name" bun:"name"`
-	Type  string `json:"type" bun:"type"`
-	Data  string `json:"data" bun:"data"`
-	OrgID string `json:"org_id" bun:"org_id"`
+	Name  string `json:"name" required:"true" bun:"name"`
+	Type  string `json:"type" required:"true" bun:"type"`
+	Data  string `json:"data" required:"true" bun:"data"`
+	OrgID string `json:"orgId" required:"true" bun:"org_id"`
 }
 
 // NewChannelFromReceiver creates a new Channel from a Receiver.

pkg/types/alertmanagertypes/expressionroute.go

@@ -12,12 +12,12 @@ import (
 )
 
 type PostableRoutePolicy struct {
-	Expression     string         `json:"expression"`
+	Expression     string         `json:"expression" required:"true"`
 	ExpressionKind ExpressionKind `json:"kind"`
-	Channels       []string       `json:"channels"`
-	Name           string         `json:"name"`
+	Channels       []string       `json:"channels" required:"true"`
+	Name           string         `json:"name" required:"true"`
 	Description    string         `json:"description"`
-	Tags           []string       `json:"tags,omitempty"`
+	Tags           []string       `json:"tags,omitempty" nullable:"true"`
 }
 
 func (p *PostableRoutePolicy) Validate() error {
@@ -53,15 +53,13 @@ func (p *PostableRoutePolicy) Validate() error {
 }
 
 type GettableRoutePolicy struct {
-	PostableRoutePolicy // Embedded
+	PostableRoutePolicy
 
-	ID string `json:"id"`
-
-	// Audit fields
-	CreatedAt *time.Time `json:"createdAt"`
-	UpdatedAt *time.Time `json:"updatedAt"`
-	CreatedBy *string    `json:"createdBy"`
-	UpdatedBy *string    `json:"updatedBy"`
+	ID        string    `json:"id" required:"true"`
+	CreatedAt time.Time `json:"createdAt" required:"true"`
+	UpdatedAt time.Time `json:"updatedAt" required:"true"`
+	CreatedBy *string   `json:"createdBy" nullable:"true"`
+	UpdatedBy *string   `json:"updatedBy" nullable:"true"`
 }
 
 type ExpressionKind struct {
@@ -73,6 +71,13 @@ var (
 	PolicyBasedExpression = ExpressionKind{valuer.NewString("policy")}
 )
 
+func (ExpressionKind) Enum() []any {
+	return []any{
+		RuleBasedExpression,
+		PolicyBasedExpression,
+	}
+}
+
 // RoutePolicy represents the database model for expression routes.
 type RoutePolicy struct {
 	bun.BaseModel `bun:"table:route_policy"`

pkg/types/inframonitoringtypes/commontypes.go

@@ -1,21 +0,0 @@
-package inframonitoringtypes
-
-import (
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type ResponseType struct {
-	valuer.String
-}
-
-var (
-	ResponseTypeList        = ResponseType{valuer.NewString("list")}
-	ResponseTypeGroupedList = ResponseType{valuer.NewString("grouped_list")}
-)
-
-func (ResponseType) Enum() []any {
-	return []any{
-		ResponseTypeList,
-		ResponseTypeGroupedList,
-	}
-}

pkg/types/inframonitoringtypes/hosts.go

@@ -1,150 +0,0 @@
-package inframonitoringtypes
-
-import (
-	"encoding/json"
-	"slices"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type HostStatus struct {
-	valuer.String
-}
-
-var (
-	HostStatusActive   = HostStatus{valuer.NewString("active")}
-	HostStatusInactive = HostStatus{valuer.NewString("inactive")}
-	HostStatusNone     = HostStatus{valuer.NewString("")}
-)
-
-func (HostStatus) Enum() []any {
-	return []any{
-		HostStatusActive,
-		HostStatusInactive,
-		HostStatusNone,
-	}
-}
-
-const (
-	HostsOrderByCPU       = "cpu"
-	HostsOrderByMemory    = "memory"
-	HostsOrderByWait      = "wait"
-	HostsOrderByDiskUsage = "disk_usage"
-	HostsOrderByLoad15    = "load15"
-)
-
-var HostsValidOrderByKeys = []string{
-	HostsOrderByCPU,
-	HostsOrderByMemory,
-	HostsOrderByWait,
-	HostsOrderByDiskUsage,
-	HostsOrderByLoad15,
-}
-
-type HostFilter struct {
-	qbtypes.Filter `json:",inline"`
-	FilterByStatus HostStatus `json:"filterByStatus"`
-}
-
-type HostsListRequest struct {
-	Start   int64                `json:"start"`
-	End     int64                `json:"end"`
-	Filter  *HostFilter          `json:"filter"`
-	GroupBy []qbtypes.GroupByKey `json:"groupBy"`
-	OrderBy *qbtypes.OrderBy     `json:"orderBy"`
-	Offset  int                  `json:"offset"`
-	Limit   int                  `json:"limit"`
-}
-
-// Validate ensures HostsListRequest contains acceptable values.
-func (req *HostsListRequest) Validate() error {
-	if req == nil {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "request is nil")
-	}
-
-	if req.Start <= 0 {
-		return errors.NewInvalidInputf(
-			errors.CodeInvalidInput,
-			"invalid start time %d: start must be greater than 0",
-			req.Start,
-		)
-	}
-
-	if req.End <= 0 {
-		return errors.NewInvalidInputf(
-			errors.CodeInvalidInput,
-			"invalid end time %d: end must be greater than 0",
-			req.End,
-		)
-	}
-
-	if req.Start >= req.End {
-		return errors.NewInvalidInputf(
-			errors.CodeInvalidInput,
-			"invalid time range: start (%d) must be less than end (%d)",
-			req.Start,
-			req.End,
-		)
-	}
-
-	if req.Limit < 1 || req.Limit > 5000 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "limit must be between 1 and 5000")
-	}
-
-	if req.Offset < 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "offset cannot be negative")
-	}
-
-	if req.Filter != nil && !req.Filter.FilterByStatus.IsZero() &&
-		req.Filter.FilterByStatus != HostStatusActive && req.Filter.FilterByStatus != HostStatusInactive {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid filter by status: %s", req.Filter.FilterByStatus)
-	}
-
-	if req.OrderBy != nil {
-		if !slices.Contains(HostsValidOrderByKeys, req.OrderBy.Key.Name) {
-			return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid order by key: %s", req.OrderBy.Key.Name)
-		}
-		if req.OrderBy.Direction != qbtypes.OrderDirectionAsc && req.OrderBy.Direction != qbtypes.OrderDirectionDesc {
-			return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid order by direction: %s", req.OrderBy.Direction)
-		}
-	}
-
-	return nil
-}
-
-// UnmarshalJSON validates input immediately after decoding.
-func (req *HostsListRequest) UnmarshalJSON(data []byte) error {
-	type raw HostsListRequest
-	var decoded raw
-	if err := json.Unmarshal(data, &decoded); err != nil {
-		return err
-	}
-	*req = HostsListRequest(decoded)
-	return req.Validate()
-}
-
-type RequiredMetricsCheck struct {
-	MissingMetrics []string `json:"missingMetrics"`
-}
-
-type HostsListResponse struct {
-	Type                   ResponseType           `json:"type"`
-	Records                []HostRecord           `json:"records"`
-	Total                  int                    `json:"total"`
-	RequiredMetricsCheck   RequiredMetricsCheck   `json:"requiredMetricsCheck"`
-	EndTimeBeforeRetention bool                   `json:"endTimeBeforeRetention"`
-	Warning                *qbtypes.QueryWarnData `json:"warning,omitempty"`
-}
-
-type HostRecord struct {
-	HostName  string                 `json:"hostName"`
-	Status    HostStatus             `json:"status"`
-	CPU       float64                `json:"cpu"`
-	Memory    float64                `json:"memory"`
-	Wait      float64                `json:"wait"`
-	Load15    float64                `json:"load15"`
-	DiskUsage float64                `json:"diskUsage"`
-	Meta      map[string]interface{} `json:"meta"`
-}

pkg/types/inframonitoringtypes/hosts_test.go

@@ -1,244 +0,0 @@
-package inframonitoringtypes
-
-import (
-	"testing"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/stretchr/testify/require"
-)
-
-func TestHostsListRequest_Validate(t *testing.T) {
-	tests := []struct {
-		name    string
-		req     *HostsListRequest
-		wantErr bool
-	}{
-		{
-			name: "valid request",
-			req: &HostsListRequest{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-			},
-			wantErr: false,
-		},
-		{
-			name:    "nil request",
-			req:     nil,
-			wantErr: true,
-		},
-		{
-			name: "start time zero",
-			req: &HostsListRequest{
-				Start:  0,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-			},
-			wantErr: true,
-		},
-		{
-			name: "start time negative",
-			req: &HostsListRequest{
-				Start:  -1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-			},
-			wantErr: true,
-		},
-		{
-			name: "end time zero",
-			req: &HostsListRequest{
-				Start:  1000,
-				End:    0,
-				Limit:  100,
-				Offset: 0,
-			},
-			wantErr: true,
-		},
-		{
-			name: "start time greater than end time",
-			req: &HostsListRequest{
-				Start:  2000,
-				End:    1000,
-				Limit:  100,
-				Offset: 0,
-			},
-			wantErr: true,
-		},
-		{
-			name: "start time equal to end time",
-			req: &HostsListRequest{
-				Start:  1000,
-				End:    1000,
-				Limit:  100,
-				Offset: 0,
-			},
-			wantErr: true,
-		},
-		{
-			name: "limit zero",
-			req: &HostsListRequest{
-				Start:  1000,
-				End:    2000,
-				Limit:  0,
-				Offset: 0,
-			},
-			wantErr: true,
-		},
-		{
-			name: "limit negative",
-			req: &HostsListRequest{
-				Start:  1000,
-				End:    2000,
-				Limit:  -10,
-				Offset: 0,
-			},
-			wantErr: true,
-		},
-		{
-			name: "limit exceeds max",
-			req: &HostsListRequest{
-				Start:  1000,
-				End:    2000,
-				Limit:  5001,
-				Offset: 0,
-			},
-			wantErr: true,
-		},
-		{
-			name: "offset negative",
-			req: &HostsListRequest{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: -5,
-			},
-			wantErr: true,
-		},
-		{
-			name: "filter by status ACTIVE",
-			req: &HostsListRequest{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-				Filter: &HostFilter{FilterByStatus: HostStatusActive},
-			},
-			wantErr: false,
-		},
-		{
-			name: "filter by status INACTIVE",
-			req: &HostsListRequest{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-				Filter: &HostFilter{FilterByStatus: HostStatusInactive},
-			},
-			wantErr: false,
-		},
-		{
-			name: "filter by status empty (zero value)",
-			req: &HostsListRequest{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-			},
-			wantErr: false,
-		},
-		{
-			name: "filter by status invalid value",
-			req: &HostsListRequest{
-				Start:          1000,
-				End:            2000,
-				Limit:          100,
-				Offset:         0,
-				Filter: &HostFilter{FilterByStatus: HostStatus{valuer.NewString("UNKNOWN")}},
-			},
-			wantErr: true,
-		},
-		{
-			name: "orderBy nil is valid",
-			req: &HostsListRequest{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-			},
-			wantErr: false,
-		},
-		{
-			name: "orderBy with valid key cpu and direction asc",
-			req: &HostsListRequest{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-				OrderBy: &qbtypes.OrderBy{
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: HostsOrderByCPU,
-						},
-					},
-					Direction: qbtypes.OrderDirectionAsc,
-				},
-			},
-			wantErr: false,
-		},
-		{
-			name: "orderBy with invalid key",
-			req: &HostsListRequest{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-				OrderBy: &qbtypes.OrderBy{
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: "unknown",
-						},
-					},
-					Direction: qbtypes.OrderDirectionDesc,
-				},
-			},
-			wantErr: true,
-		},
-		{
-			name: "orderBy with valid key but invalid direction",
-			req: &HostsListRequest{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-				OrderBy: &qbtypes.OrderBy{
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: HostsOrderByMemory,
-						},
-					},
-					Direction: qbtypes.OrderDirection{String: valuer.NewString("invalid")},
-				},
-			},
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := tt.req.Validate()
-			if tt.wantErr {
-				require.Error(t, err)
-				require.True(t, errors.Ast(err, errors.TypeInvalidInput), "expected error to be of type InvalidInput")
-			} else {
-				require.NoError(t, err)
-			}
-		})
-	}
-}