feat: 1.Types for ai-o11y ricing rules

* feat: adding query params in cloud integration APIs

* refactor: create account HTTP status change from OK to CREATED

docs/api/openapi.yml

@@ -1,5 +1,169 @@
 components:
   schemas:
+    Aio11YtypesCacheMode:
+      enum:
+      - subtract
+      - additive
+      - unknown
+      nullable: true
+      type: string
+    Aio11YtypesGettablePricingRule:
+      properties:
+        cache_mode:
+          $ref: '#/components/schemas/Aio11YtypesCacheMode'
+        cost_cache_read:
+          format: double
+          type: number
+        cost_cache_write:
+          format: double
+          type: number
+        cost_input:
+          format: double
+          type: number
+        cost_output:
+          format: double
+          type: number
+        created_at:
+          format: date-time
+          type: string
+        created_by:
+          type: string
+        enabled:
+          type: boolean
+        id:
+          type: string
+        is_override:
+          type: boolean
+        model_name:
+          type: string
+        model_pattern:
+          items:
+            type: string
+          nullable: true
+          type: array
+        synced_at:
+          format: date-time
+          nullable: true
+          type: string
+        unit:
+          $ref: '#/components/schemas/Aio11YtypesUnit'
+        updated_at:
+          format: date-time
+          type: string
+        updated_by:
+          type: string
+      required:
+      - id
+      - model_name
+      - model_pattern
+      - unit
+      - cache_mode
+      - cost_input
+      - cost_output
+      - cost_cache_read
+      - cost_cache_write
+      - is_override
+      - enabled
+      - created_at
+      - updated_at
+      - created_by
+      - updated_by
+      type: object
+    Aio11YtypesListPricingRulesResponse:
+      properties:
+        items:
+          items:
+            $ref: '#/components/schemas/Aio11YtypesGettablePricingRule'
+          nullable: true
+          type: array
+        limit:
+          type: integer
+        offset:
+          type: integer
+        total:
+          type: integer
+      required:
+      - items
+      - total
+      - offset
+      - limit
+      type: object
+    Aio11YtypesPostablePricingRule:
+      properties:
+        cache_mode:
+          $ref: '#/components/schemas/Aio11YtypesCacheMode'
+        cost_cache_read:
+          format: double
+          type: number
+        cost_cache_write:
+          format: double
+          type: number
+        cost_input:
+          format: double
+          type: number
+        cost_output:
+          format: double
+          type: number
+        enabled:
+          type: boolean
+        model_name:
+          type: string
+        model_pattern:
+          items:
+            type: string
+          nullable: true
+          type: array
+        unit:
+          $ref: '#/components/schemas/Aio11YtypesUnit'
+      required:
+      - model_name
+      - model_pattern
+      - unit
+      - cache_mode
+      - cost_input
+      - cost_output
+      - cost_cache_read
+      - cost_cache_write
+      - enabled
+      type: object
+    Aio11YtypesUnit:
+      enum:
+      - per_million_tokens
+      - per_token
+      nullable: true
+      type: string
+    Aio11YtypesUpdatablePricingRule:
+      properties:
+        cache_mode:
+          $ref: '#/components/schemas/Aio11YtypesCacheMode'
+        cost_cache_read:
+          nullable: true
+          type: number
+        cost_cache_write:
+          nullable: true
+          type: number
+        cost_input:
+          nullable: true
+          type: number
+        cost_output:
+          nullable: true
+          type: number
+        enabled:
+          nullable: true
+          type: boolean
+        is_override:
+          nullable: true
+          type: boolean
+        model_name:
+          nullable: true
+          type: string
+        model_pattern:
+          items:
+            type: string
+          type: array
+        unit:
+          $ref: '#/components/schemas/Aio11YtypesUnit'
+      type: object
     AuthtypesAttributeMapping:
       properties:
         email:
@@ -1215,93 +1379,6 @@ components:
         enabled:
           type: boolean
       type: object
-    InframonitoringtypesHostRecord:
-      properties:
-        cpu:
-          format: double
-          type: number
-        diskUsage:
-          format: double
-          type: number
-        hostName:
-          type: string
-        load15:
-          format: double
-          type: number
-        memory:
-          format: double
-          type: number
-        meta:
-          additionalProperties: {}
-          nullable: true
-          type: object
-        status:
-          $ref: '#/components/schemas/InframonitoringtypesHostStatus'
-        wait:
-          format: double
-          type: number
-      type: object
-    InframonitoringtypesHostStatus:
-      enum:
-      - active
-      - inactive
-      - ""
-      type: string
-    InframonitoringtypesHostsListRequest:
-      properties:
-        end:
-          format: int64
-          type: integer
-        filter:
-          $ref: '#/components/schemas/Querybuildertypesv5Filter'
-        filterByStatus:
-          $ref: '#/components/schemas/InframonitoringtypesHostStatus'
-        groupBy:
-          items:
-            $ref: '#/components/schemas/Querybuildertypesv5GroupByKey'
-          nullable: true
-          type: array
-        limit:
-          type: integer
-        offset:
-          type: integer
-        orderBy:
-          $ref: '#/components/schemas/Querybuildertypesv5OrderBy'
-        start:
-          format: int64
-          type: integer
-      type: object
-    InframonitoringtypesHostsListResponse:
-      properties:
-        endTimeBeforeRetention:
-          type: boolean
-        records:
-          items:
-            $ref: '#/components/schemas/InframonitoringtypesHostRecord'
-          nullable: true
-          type: array
-        requiredMetricsCheck:
-          $ref: '#/components/schemas/InframonitoringtypesRequiredMetricsCheck'
-        total:
-          type: integer
-        type:
-          $ref: '#/components/schemas/InframonitoringtypesResponseType'
-        warning:
-          $ref: '#/components/schemas/Querybuildertypesv5QueryWarnData'
-      type: object
-    InframonitoringtypesRequiredMetricsCheck:
-      properties:
-        missingMetrics:
-          items:
-            type: string
-          nullable: true
-          type: array
-      type: object
-    InframonitoringtypesResponseType:
-      enum:
-      - list
-      - grouped_list
-      type: string
     MetricsexplorertypesInspectMetricsRequest:
       properties:
         end:
@@ -3145,6 +3222,303 @@ info:
   version: ""
 openapi: 3.0.3
 paths:
+  /api/v1/ai-o11y/pricing/rules:
+    get:
+      deprecated: false
+      description: Returns all LLM pricing rules for the authenticated org, with pagination.
+      operationId: ListPricingRules
+      parameters:
+      - in: query
+        name: offset
+        schema:
+          type: integer
+      - in: query
+        name: limit
+        schema:
+          type: integer
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/Aio11YtypesListPricingRulesResponse'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: List pricing rules
+      tags:
+      - ai-o11y
+    post:
+      deprecated: false
+      description: Creates a new LLM pricing rule for the org. Always sets is_override
+        = true.
+      operationId: CreatePricingRule
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/Aio11YtypesPostablePricingRule'
+      responses:
+        "201":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/Aio11YtypesGettablePricingRule'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: Created
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "409":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Conflict
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - ADMIN
+      - tokenizer:
+        - ADMIN
+      summary: Create a pricing rule
+      tags:
+      - ai-o11y
+  /api/v1/ai-o11y/pricing/rules/{id}:
+    delete:
+      deprecated: false
+      description: Hard-deletes a pricing rule. If auto-synced, it will be recreated
+        on the next sync cycle.
+      operationId: DeletePricingRule
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      responses:
+        "204":
+          description: No Content
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - ADMIN
+      - tokenizer:
+        - ADMIN
+      summary: Delete a pricing rule
+      tags:
+      - ai-o11y
+    get:
+      deprecated: false
+      description: Returns a single LLM pricing rule by ID.
+      operationId: GetPricingRule
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/Aio11YtypesGettablePricingRule'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: Get a pricing rule
+      tags:
+      - ai-o11y
+    put:
+      deprecated: false
+      description: Partially updates an existing pricing rule. Changing any cost field
+        sets is_override = true.
+      operationId: UpdatePricingRule
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/Aio11YtypesUpdatablePricingRule'
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/Aio11YtypesGettablePricingRule'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - ADMIN
+      - tokenizer:
+        - ADMIN
+      summary: Update a pricing rule
+      tags:
+      - ai-o11y
   /api/v1/authz/check:
     post:
       deprecated: false
@@ -3396,7 +3770,7 @@ paths:
             schema:
               $ref: '#/components/schemas/CloudintegrationtypesPostableAccount'
       responses:
-        "200":
+        "201":
           content:
             application/json:
               schema:
@@ -3409,7 +3783,7 @@ paths:
                 - status
                 - data
                 type: object
-          description: OK
+          description: Created
         "401":
           content:
             application/json:
@@ -3770,6 +4144,11 @@ paths:
         provider
       operationId: ListServicesMetadata
       parameters:
+      - in: query
+        name: cloud_integration_id
+        required: false
+        schema:
+          type: string
       - in: path
         name: cloud_provider
         required: true
@@ -3822,6 +4201,11 @@ paths:
       description: This endpoint gets a service for the specified cloud provider
       operationId: GetService
       parameters:
+      - in: query
+        name: cloud_integration_id
+        required: false
+        schema:
+          type: string
       - in: path
         name: cloud_provider
         required: true
@@ -7443,72 +7827,6 @@ paths:
       summary: Health check
       tags:
       - health
-  /api/v2/infra_monitoring/hosts:
-    post:
-      deprecated: false
-      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.'
-      operationId: HostsList
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/InframonitoringtypesHostsListRequest'
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/InframonitoringtypesHostsListResponse'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: List Hosts for Infra Monitoring
-      tags:
-      - infra-monitoring
   /api/v2/livez:
     get:
       deprecated: false

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

@@ -28,7 +28,7 @@ import type {
 	CloudintegrationtypesPostableAgentCheckInDTO,
 	CloudintegrationtypesUpdatableAccountDTO,
 	CloudintegrationtypesUpdatableServiceDTO,
-	CreateAccount200,
+	CreateAccount201,
 	CreateAccountPathParameters,
 	DisconnectAccountPathParameters,
 	GetAccount200,
@@ -36,10 +36,12 @@ import type {
 	GetConnectionCredentials200,
 	GetConnectionCredentialsPathParameters,
 	GetService200,
+	GetServiceParams,
 	GetServicePathParameters,
 	ListAccounts200,
 	ListAccountsPathParameters,
 	ListServicesMetadata200,
+	ListServicesMetadataParams,
 	ListServicesMetadataPathParameters,
 	RenderErrorResponseDTO,
 	UpdateAccountPathParameters,
@@ -260,7 +262,7 @@ export const createAccount = (
 	cloudintegrationtypesPostableAccountDTO: BodyType<CloudintegrationtypesPostableAccountDTO>,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<CreateAccount200>({
+	return GeneratedAPIInstance<CreateAccount201>({
 		url: `/api/v1/cloud_integrations/${cloudProvider}/accounts`,
 		method: 'POST',
 		headers: { 'Content-Type': 'application/json' },
@@ -940,19 +942,25 @@ export const invalidateGetConnectionCredentials = async (
  */
 export const listServicesMetadata = (
 	{ cloudProvider }: ListServicesMetadataPathParameters,
+	params?: ListServicesMetadataParams,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<ListServicesMetadata200>({
 		url: `/api/v1/cloud_integrations/${cloudProvider}/services`,
 		method: 'GET',
+		params,
 		signal,
 	});
 };
 
-export const getListServicesMetadataQueryKey = ({
-	cloudProvider,
-}: ListServicesMetadataPathParameters) => {
-	return [`/api/v1/cloud_integrations/${cloudProvider}/services`] as const;
+export const getListServicesMetadataQueryKey = (
+	{ cloudProvider }: ListServicesMetadataPathParameters,
+	params?: ListServicesMetadataParams,
+) => {
+	return [
+		`/api/v1/cloud_integrations/${cloudProvider}/services`,
+		...(params ? [params] : []),
+	] as const;
 };
 
 export const getListServicesMetadataQueryOptions = <
@@ -960,6 +968,7 @@ export const getListServicesMetadataQueryOptions = <
 	TError = ErrorType<RenderErrorResponseDTO>
 >(
 	{ cloudProvider }: ListServicesMetadataPathParameters,
+	params?: ListServicesMetadataParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof listServicesMetadata>>,
@@ -971,11 +980,12 @@ export const getListServicesMetadataQueryOptions = <
 	const { query: queryOptions } = options ?? {};
 
 	const queryKey =
-		queryOptions?.queryKey ?? getListServicesMetadataQueryKey({ cloudProvider });
+		queryOptions?.queryKey ??
+		getListServicesMetadataQueryKey({ cloudProvider }, params);
 
 	const queryFn: QueryFunction<
 		Awaited<ReturnType<typeof listServicesMetadata>>
-	> = ({ signal }) => listServicesMetadata({ cloudProvider }, signal);
+	> = ({ signal }) => listServicesMetadata({ cloudProvider }, params, signal);
 
 	return {
 		queryKey,
@@ -1003,6 +1013,7 @@ export function useListServicesMetadata<
 	TError = ErrorType<RenderErrorResponseDTO>
 >(
 	{ cloudProvider }: ListServicesMetadataPathParameters,
+	params?: ListServicesMetadataParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof listServicesMetadata>>,
@@ -1013,6 +1024,7 @@ export function useListServicesMetadata<
 ): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
 	const queryOptions = getListServicesMetadataQueryOptions(
 		{ cloudProvider },
+		params,
 		options,
 	);
 
@@ -1031,10 +1043,11 @@ export function useListServicesMetadata<
 export const invalidateListServicesMetadata = async (
 	queryClient: QueryClient,
 	{ cloudProvider }: ListServicesMetadataPathParameters,
+	params?: ListServicesMetadataParams,
 	options?: InvalidateOptions,
 ): Promise<QueryClient> => {
 	await queryClient.invalidateQueries(
-		{ queryKey: getListServicesMetadataQueryKey({ cloudProvider }) },
+		{ queryKey: getListServicesMetadataQueryKey({ cloudProvider }, params) },
 		options,
 	);
 
@@ -1047,21 +1060,24 @@ export const invalidateListServicesMetadata = async (
  */
 export const getService = (
 	{ cloudProvider, serviceId }: GetServicePathParameters,
+	params?: GetServiceParams,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<GetService200>({
 		url: `/api/v1/cloud_integrations/${cloudProvider}/services/${serviceId}`,
 		method: 'GET',
+		params,
 		signal,
 	});
 };
 
-export const getGetServiceQueryKey = ({
-	cloudProvider,
-	serviceId,
-}: GetServicePathParameters) => {
+export const getGetServiceQueryKey = (
+	{ cloudProvider, serviceId }: GetServicePathParameters,
+	params?: GetServiceParams,
+) => {
 	return [
 		`/api/v1/cloud_integrations/${cloudProvider}/services/${serviceId}`,
+		...(params ? [params] : []),
 	] as const;
 };
 
@@ -1070,6 +1086,7 @@ export const getGetServiceQueryOptions = <
 	TError = ErrorType<RenderErrorResponseDTO>
 >(
 	{ cloudProvider, serviceId }: GetServicePathParameters,
+	params?: GetServiceParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof getService>>,
@@ -1081,11 +1098,12 @@ export const getGetServiceQueryOptions = <
 	const { query: queryOptions } = options ?? {};
 
 	const queryKey =
-		queryOptions?.queryKey ?? getGetServiceQueryKey({ cloudProvider, serviceId });
+		queryOptions?.queryKey ??
+		getGetServiceQueryKey({ cloudProvider, serviceId }, params);
 
 	const queryFn: QueryFunction<Awaited<ReturnType<typeof getService>>> = ({
 		signal,
-	}) => getService({ cloudProvider, serviceId }, signal);
+	}) => getService({ cloudProvider, serviceId }, params, signal);
 
 	return {
 		queryKey,
@@ -1111,6 +1129,7 @@ export function useGetService<
 	TError = ErrorType<RenderErrorResponseDTO>
 >(
 	{ cloudProvider, serviceId }: GetServicePathParameters,
+	params?: GetServiceParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof getService>>,
@@ -1121,6 +1140,7 @@ export function useGetService<
 ): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
 	const queryOptions = getGetServiceQueryOptions(
 		{ cloudProvider, serviceId },
+		params,
 		options,
 	);
 
@@ -1139,10 +1159,11 @@ export function useGetService<
 export const invalidateGetService = async (
 	queryClient: QueryClient,
 	{ cloudProvider, serviceId }: GetServicePathParameters,
+	params?: GetServiceParams,
 	options?: InvalidateOptions,
 ): Promise<QueryClient> => {
 	await queryClient.invalidateQueries(
-		{ queryKey: getGetServiceQueryKey({ cloudProvider, serviceId }) },
+		{ queryKey: getGetServiceQueryKey({ cloudProvider, serviceId }, params) },
 		options,
 	);
 

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/sigNoz.schemas.ts

@@ -1448,116 +1448,6 @@ export interface GlobaltypesTokenizerConfigDTO {
 	enabled?: boolean;
 }
 
-/**
- * @nullable
- */
-export type InframonitoringtypesHostRecordDTOMeta = {
-	[key: string]: unknown;
-} | null;
-
-export interface InframonitoringtypesHostRecordDTO {
-	/**
-	 * @type number
-	 * @format double
-	 */
-	cpu?: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	diskUsage?: number;
-	/**
-	 * @type string
-	 */
-	hostName?: string;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	load15?: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	memory?: number;
-	/**
-	 * @type object
-	 * @nullable true
-	 */
-	meta?: InframonitoringtypesHostRecordDTOMeta;
-	status?: InframonitoringtypesHostStatusDTO;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	wait?: number;
-}
-
-export enum InframonitoringtypesHostStatusDTO {
-	active = 'active',
-	inactive = 'inactive',
-	'' = '',
-}
-export interface InframonitoringtypesHostsListRequestDTO {
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	end?: number;
-	filter?: Querybuildertypesv5FilterDTO;
-	filterByStatus?: InframonitoringtypesHostStatusDTO;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	groupBy?: Querybuildertypesv5GroupByKeyDTO[] | null;
-	/**
-	 * @type integer
-	 */
-	limit?: number;
-	/**
-	 * @type integer
-	 */
-	offset?: number;
-	orderBy?: Querybuildertypesv5OrderByDTO;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	start?: number;
-}
-
-export interface InframonitoringtypesHostsListResponseDTO {
-	/**
-	 * @type boolean
-	 */
-	endTimeBeforeRetention?: boolean;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	records?: InframonitoringtypesHostRecordDTO[] | null;
-	requiredMetricsCheck?: InframonitoringtypesRequiredMetricsCheckDTO;
-	/**
-	 * @type integer
-	 */
-	total?: number;
-	type?: InframonitoringtypesResponseTypeDTO;
-	warning?: Querybuildertypesv5QueryWarnDataDTO;
-}
-
-export interface InframonitoringtypesRequiredMetricsCheckDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	missingMetrics?: string[] | null;
-}
-
-export enum InframonitoringtypesResponseTypeDTO {
-	list = 'list',
-	grouped_list = 'grouped_list',
-}
 export interface MetricsexplorertypesInspectMetricsRequestDTO {
 	/**
 	 * @type integer
@@ -3699,7 +3589,7 @@ export type ListAccounts200 = {
 export type CreateAccountPathParameters = {
 	cloudProvider: string;
 };
-export type CreateAccount200 = {
+export type CreateAccount201 = {
 	data: CloudintegrationtypesGettableAccountWithConnectionArtifactDTO;
 	/**
 	 * @type string
@@ -3757,6 +3647,14 @@ export type GetConnectionCredentials200 = {
 export type ListServicesMetadataPathParameters = {
 	cloudProvider: string;
 };
+export type ListServicesMetadataParams = {
+	/**
+	 * @type string
+	 * @description undefined
+	 */
+	cloud_integration_id?: string;
+};
+
 export type ListServicesMetadata200 = {
 	data: CloudintegrationtypesGettableServicesMetadataDTO;
 	/**
@@ -3769,6 +3667,14 @@ export type GetServicePathParameters = {
 	cloudProvider: string;
 	serviceId: string;
 };
+export type GetServiceParams = {
+	/**
+	 * @type string
+	 * @description undefined
+	 */
+	cloud_integration_id?: string;
+};
+
 export type GetService200 = {
 	data: CloudintegrationtypesServiceDTO;
 	/**
@@ -4432,14 +4338,6 @@ export type Healthz503 = {
 	status: string;
 };
 
-export type HostsList200 = {
-	data: InframonitoringtypesHostsListResponseDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type Livez200 = {
 	data: FactoryResponseDTO;
 	/**

pkg/apiserver/signozapiserver/aio11y.go

@@ -0,0 +1,115 @@
+package signozapiserver
+
+import (
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/http/handler"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/aio11ypricingruletypes"
+	"github.com/gorilla/mux"
+)
+
+func (provider *provider) addAIO11yRoutes(router *mux.Router) error {
+	if err := router.Handle("/api/v1/ai-o11y/pricing/rules", handler.New(
+		provider.authZ.ViewAccess(provider.aiO11yPricingRuleHandler.List),
+		handler.OpenAPIDef{
+			ID:                  "ListPricingRules",
+			Tags:                []string{"ai-o11y"},
+			Summary:             "List pricing rules",
+			Description:         "Returns all LLM pricing rules for the authenticated org, with pagination.",
+			Request:             nil,
+			RequestContentType:  "",
+			RequestQuery:        new(aio11ypricingruletypes.ListPricingRulesQuery),
+			Response:            new(aio11ypricingruletypes.ListPricingRulesResponse),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusOK,
+			ErrorStatusCodes:    []int{http.StatusBadRequest},
+			Deprecated:          false,
+			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+		},
+	)).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/ai-o11y/pricing/rules", handler.New(
+		provider.authZ.AdminAccess(provider.aiO11yPricingRuleHandler.Create),
+		handler.OpenAPIDef{
+			ID:                  "CreatePricingRule",
+			Tags:                []string{"ai-o11y"},
+			Summary:             "Create a pricing rule",
+			Description:         "Creates a new LLM pricing rule for the org. Always sets is_override = true.",
+			Request:             new(aio11ypricingruletypes.PostablePricingRule),
+			RequestContentType:  "application/json",
+			Response:            new(aio11ypricingruletypes.GettablePricingRule),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusCreated,
+			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusConflict},
+			Deprecated:          false,
+			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
+		},
+	)).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/ai-o11y/pricing/rules/{id}", handler.New(
+		provider.authZ.ViewAccess(provider.aiO11yPricingRuleHandler.Get),
+		handler.OpenAPIDef{
+			ID:                  "GetPricingRule",
+			Tags:                []string{"ai-o11y"},
+			Summary:             "Get a pricing rule",
+			Description:         "Returns a single LLM pricing rule by ID.",
+			Request:             nil,
+			RequestContentType:  "",
+			Response:            new(aio11ypricingruletypes.GettablePricingRule),
+			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/ai-o11y/pricing/rules/{id}", handler.New(
+		provider.authZ.AdminAccess(provider.aiO11yPricingRuleHandler.Update),
+		handler.OpenAPIDef{
+			ID:                  "UpdatePricingRule",
+			Tags:                []string{"ai-o11y"},
+			Summary:             "Update a pricing rule",
+			Description:         "Partially updates an existing pricing rule. Changing any cost field sets is_override = true.",
+			Request:             new(aio11ypricingruletypes.UpdatablePricingRule),
+			RequestContentType:  "application/json",
+			Response:            new(aio11ypricingruletypes.GettablePricingRule),
+			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/ai-o11y/pricing/rules/{id}", handler.New(
+		provider.authZ.AdminAccess(provider.aiO11yPricingRuleHandler.Delete),
+		handler.OpenAPIDef{
+			ID:                  "DeletePricingRule",
+			Tags:                []string{"ai-o11y"},
+			Summary:             "Delete a pricing rule",
+			Description:         "Hard-deletes a pricing rule. If auto-synced, it will be recreated on the next sync cycle.",
+			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
+	}
+
+	return nil
+}

pkg/apiserver/signozapiserver/cloudintegration.go

@@ -41,7 +41,7 @@ func (provider *provider) addCloudIntegrationRoutes(router *mux.Router) error {
 			RequestContentType:  "application/json",
 			Response:            new(citypes.GettableAccountWithConnectionArtifact),
 			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
+			SuccessStatusCode:   http.StatusCreated,
 			ErrorStatusCodes:    []int{},
 			Deprecated:          false,
 			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
@@ -138,6 +138,7 @@ func (provider *provider) addCloudIntegrationRoutes(router *mux.Router) error {
 			Summary:             "List services metadata",
 			Description:         "This endpoint lists the services metadata for the specified cloud provider",
 			Request:             nil,
+			RequestQuery:        new(citypes.ListServicesMetadataParams),
 			RequestContentType:  "",
 			Response:            new(citypes.GettableServicesMetadata),
 			ResponseContentType: "application/json",
@@ -158,6 +159,7 @@ func (provider *provider) addCloudIntegrationRoutes(router *mux.Router) error {
 			Summary:             "Get service",
 			Description:         "This endpoint gets a service for the specified cloud provider",
 			Request:             nil,
+			RequestQuery:        new(citypes.GetServiceParams),
 			RequestContentType:  "",
 			Response:            new(citypes.Service),
 			ResponseContentType: "application/json",

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

@@ -11,12 +11,12 @@ import (
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/http/handler"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
+	"github.com/SigNoz/signoz/pkg/modules/aio11ypricingrule"
 	"github.com/SigNoz/signoz/pkg/modules/authdomain"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"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"
@@ -33,32 +33,32 @@ import (
 )
 
 type provider struct {
-	config                  apiserver.Config
-	settings                factory.ScopedProviderSettings
-	router                  *mux.Router
-	authZ                   *middleware.AuthZ
-	orgHandler              organization.Handler
-	userHandler             user.Handler
-	sessionHandler          session.Handler
-	authDomainHandler       authdomain.Handler
-	preferenceHandler       preference.Handler
-	globalHandler           global.Handler
-	promoteHandler          promote.Handler
-	flaggerHandler          flagger.Handler
-	dashboardModule         dashboard.Module
-	dashboardHandler        dashboard.Handler
-	metricsExplorerHandler  metricsexplorer.Handler
-	infraMonitoringHandler  inframonitoring.Handler
-	gatewayHandler          gateway.Handler
-	fieldsHandler           fields.Handler
-	authzHandler            authz.Handler
-	rawDataExportHandler    rawdataexport.Handler
-	zeusHandler             zeus.Handler
-	querierHandler          querier.Handler
-	serviceAccountHandler   serviceaccount.Handler
-	factoryHandler          factory.Handler
-	cloudIntegrationHandler cloudintegration.Handler
-	ruleStateHistoryHandler rulestatehistory.Handler
+	config                   apiserver.Config
+	settings                 factory.ScopedProviderSettings
+	router                   *mux.Router
+	authZ                    *middleware.AuthZ
+	orgHandler               organization.Handler
+	userHandler              user.Handler
+	sessionHandler           session.Handler
+	authDomainHandler        authdomain.Handler
+	preferenceHandler        preference.Handler
+	globalHandler            global.Handler
+	promoteHandler           promote.Handler
+	flaggerHandler           flagger.Handler
+	dashboardModule          dashboard.Module
+	dashboardHandler         dashboard.Handler
+	metricsExplorerHandler   metricsexplorer.Handler
+	gatewayHandler           gateway.Handler
+	fieldsHandler            fields.Handler
+	authzHandler             authz.Handler
+	rawDataExportHandler     rawdataexport.Handler
+	zeusHandler              zeus.Handler
+	querierHandler           querier.Handler
+	serviceAccountHandler    serviceaccount.Handler
+	factoryHandler           factory.Handler
+	cloudIntegrationHandler  cloudintegration.Handler
+	ruleStateHistoryHandler  rulestatehistory.Handler
+	aiO11yPricingRuleHandler aio11ypricingrule.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,
+	aiO11yPricingRuleHandler aio11ypricingrule.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,
+			aiO11yPricingRuleHandler,
 		)
 	})
 }
@@ -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,36 +147,37 @@ func newProvider(
 	factoryHandler factory.Handler,
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
+	aiO11yPricingRuleHandler aio11ypricingrule.Handler,
 ) (apiserver.APIServer, error) {
 	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/apiserver/signozapiserver")
 	router := mux.NewRouter().UseEncodedPath()
 
 	provider := &provider{
-		config:                  config,
-		settings:                settings,
-		router:                  router,
-		orgHandler:              orgHandler,
-		userHandler:             userHandler,
-		sessionHandler:          sessionHandler,
-		authDomainHandler:       authDomainHandler,
-		preferenceHandler:       preferenceHandler,
-		globalHandler:           globalHandler,
-		promoteHandler:          promoteHandler,
-		flaggerHandler:          flaggerHandler,
-		dashboardModule:         dashboardModule,
-		dashboardHandler:        dashboardHandler,
-		metricsExplorerHandler:  metricsExplorerHandler,
-		infraMonitoringHandler:  infraMonitoringHandler,
-		gatewayHandler:          gatewayHandler,
-		fieldsHandler:           fieldsHandler,
-		authzHandler:            authzHandler,
-		rawDataExportHandler:    rawDataExportHandler,
-		zeusHandler:             zeusHandler,
-		querierHandler:          querierHandler,
-		serviceAccountHandler:   serviceAccountHandler,
-		factoryHandler:          factoryHandler,
-		cloudIntegrationHandler: cloudIntegrationHandler,
-		ruleStateHistoryHandler: ruleStateHistoryHandler,
+		config:                   config,
+		settings:                 settings,
+		router:                   router,
+		orgHandler:               orgHandler,
+		userHandler:              userHandler,
+		sessionHandler:           sessionHandler,
+		authDomainHandler:        authDomainHandler,
+		preferenceHandler:        preferenceHandler,
+		globalHandler:            globalHandler,
+		promoteHandler:           promoteHandler,
+		flaggerHandler:           flaggerHandler,
+		dashboardModule:          dashboardModule,
+		dashboardHandler:         dashboardHandler,
+		metricsExplorerHandler:   metricsExplorerHandler,
+		gatewayHandler:           gatewayHandler,
+		fieldsHandler:            fieldsHandler,
+		authzHandler:             authzHandler,
+		rawDataExportHandler:     rawDataExportHandler,
+		zeusHandler:              zeusHandler,
+		querierHandler:           querierHandler,
+		serviceAccountHandler:    serviceAccountHandler,
+		factoryHandler:           factoryHandler,
+		cloudIntegrationHandler:  cloudIntegrationHandler,
+		ruleStateHistoryHandler:  ruleStateHistoryHandler,
+		aiO11yPricingRuleHandler: aiO11yPricingRuleHandler,
 	}
 
 	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.addAIO11yRoutes(router); err != nil {
+		return err
+	}
+
 	return nil
 }
 

pkg/modules/aio11ypricingrule/aio11y.go

@@ -0,0 +1,26 @@
+package aio11ypricingrule
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/types/aio11ypricingruletypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type Module interface {
+	List(ctx context.Context, orgID valuer.UUID, offset, limit int) ([]*aio11ypricingruletypes.PricingRule, int, error)
+	Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*aio11ypricingruletypes.PricingRule, error)
+	Create(ctx context.Context, orgID valuer.UUID, createdBy string, req *aio11ypricingruletypes.PostablePricingRule) (*aio11ypricingruletypes.PricingRule, error)
+	Update(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, req *aio11ypricingruletypes.UpdatablePricingRule) (*aio11ypricingruletypes.PricingRule, error)
+	Delete(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
+}
+
+// Handler defines the HTTP handler interface for pricing rule endpoints.
+type Handler interface {
+	List(rw http.ResponseWriter, r *http.Request)
+	Get(rw http.ResponseWriter, r *http.Request)
+	Create(rw http.ResponseWriter, r *http.Request)
+	Update(rw http.ResponseWriter, r *http.Request)
+	Delete(rw http.ResponseWriter, r *http.Request)
+}

pkg/modules/aio11ypricingrule/implaio11ypricingrule/handler.go

@@ -0,0 +1,226 @@
+package implaio11ypricingrule
+
+import (
+	"context"
+	"net/http"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/http/binding"
+	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/SigNoz/signoz/pkg/modules/aio11ypricingrule"
+	"github.com/SigNoz/signoz/pkg/types/aio11ypricingruletypes"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/gorilla/mux"
+)
+
+const maxLimit = 100
+
+type handler struct {
+	module           aio11ypricingrule.Module
+	providerSettings factory.ProviderSettings
+}
+
+func NewHandler(module aio11ypricingrule.Module, providerSettings factory.ProviderSettings) aio11ypricingrule.Handler {
+	return &handler{module: module, providerSettings: providerSettings}
+}
+
+// List handles GET /api/v1/ai-o11y/pricing/rules.
+func (h *handler) List(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	var q aio11ypricingruletypes.ListPricingRulesQuery
+	if err := binding.Query.BindQuery(r.URL.Query(), &q); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	if q.Limit <= 0 {
+		q.Limit = 20
+	} else if q.Limit > maxLimit {
+		q.Limit = maxLimit
+	}
+	if q.Offset < 0 {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, aio11ypricingruletypes.ErrCodePricingRuleInvalidInput, "offset must be a non-negative integer"))
+		return
+	}
+
+	rules, total, err := h.module.List(ctx, orgID, q.Offset, q.Limit)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	items := make([]*aio11ypricingruletypes.GettablePricingRule, len(rules))
+	for i, r := range rules {
+		items[i] = aio11ypricingruletypes.NewGettablePricingRule(r)
+	}
+
+	render.Success(rw, http.StatusOK, &aio11ypricingruletypes.ListPricingRulesResponse{
+		Items:  items,
+		Total:  total,
+		Offset: q.Offset,
+		Limit:  q.Limit,
+	})
+}
+
+// Get handles GET /api/v1/ai-o11y/pricing/rules/{id}.
+func (h *handler) Get(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	id, err := ruleIDFromPath(r)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	rule, err := h.module.Get(ctx, orgID, id)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, aio11ypricingruletypes.NewGettablePricingRule(rule))
+}
+
+// Create handles POST /api/v1/ai-o11y/pricing/rules.
+func (h *handler) Create(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	req := new(aio11ypricingruletypes.PostablePricingRule)
+	if err := binding.JSON.BindBody(r.Body, req); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	rule, err := h.module.Create(ctx, orgID, claims.Email, req)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusCreated, aio11ypricingruletypes.NewGettablePricingRule(rule))
+}
+
+// Update handles PUT /api/v1/ai-o11y/pricing/rules/{id}
+func (h *handler) Update(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	id, err := ruleIDFromPath(r)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	req := new(aio11ypricingruletypes.UpdatablePricingRule)
+	if err := binding.JSON.BindBody(r.Body, req); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	rule, err := h.module.Update(ctx, orgID, id, claims.Email, req)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, aio11ypricingruletypes.NewGettablePricingRule(rule))
+}
+
+// Delete handles DELETE /api/v1/ai-o11y/pricing/rules/{id}
+func (h *handler) Delete(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	id, err := ruleIDFromPath(r)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	if err := h.module.Delete(ctx, orgID, id); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusNoContent, nil)
+}
+
+// ruleIDFromPath extracts and validates the {id} path variable.
+func ruleIDFromPath(r *http.Request) (valuer.UUID, error) {
+	raw := mux.Vars(r)["id"]
+	if raw == "" {
+		return valuer.UUID{}, errors.Newf(errors.TypeInvalidInput, aio11ypricingruletypes.ErrCodePricingRuleInvalidInput, "id is missing from the path")
+	}
+	id, err := valuer.NewUUID(raw)
+	if err != nil {
+		return valuer.UUID{}, errors.Wrapf(err, errors.TypeInvalidInput, aio11ypricingruletypes.ErrCodePricingRuleInvalidInput, "id is not a valid uuid")
+	}
+	return id, 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,274 +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
-}
-
-// 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,492 +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.FilterByStatus != inframonitoringtypes.HostStatusActive && req.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.FilterByStatus == inframonitoringtypes.HostStatusActive
-	}
-
-	op := "IN"
-	if req.FilterByStatus == inframonitoringtypes.HostStatusInactive {
-		op = "NOT IN"
-	}
-	if req.Filter == nil {
-		req.Filter = &qbtypes.Filter{}
-	}
-	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)
-		}
-	}
-	metadataMap, err := m.getMetadata(ctx, hostsTableMetricNamesList, req.GroupBy, nonGroupByAttrs, req.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.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,143 +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
-	}
-
-	// 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/signoz/config.go

@@ -22,7 +22,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/identn"
 	"github.com/SigNoz/signoz/pkg/instrumentation"
-	"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"
@@ -114,9 +113,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"`
 
@@ -157,7 +153,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

@@ -10,6 +10,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/global/signozglobal"
 	"github.com/SigNoz/signoz/pkg/licensing"
+	"github.com/SigNoz/signoz/pkg/modules/aio11ypricingrule"
 	"github.com/SigNoz/signoz/pkg/modules/apdex"
 	"github.com/SigNoz/signoz/pkg/modules/apdex/implapdex"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
@@ -18,8 +19,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"
@@ -44,27 +43,27 @@ import (
 )
 
 type Handlers struct {
-	SavedView               savedview.Handler
-	Apdex                   apdex.Handler
-	Dashboard               dashboard.Handler
-	QuickFilter             quickfilter.Handler
-	TraceFunnel             tracefunnel.Handler
-	RawDataExport           rawdataexport.Handler
-	SpanPercentile          spanpercentile.Handler
-	Services                services.Handler
-	MetricsExplorer         metricsexplorer.Handler
-	InfraMonitoring         inframonitoring.Handler
-	Global                  global.Handler
-	FlaggerHandler          flagger.Handler
-	GatewayHandler          gateway.Handler
-	Fields                  fields.Handler
-	AuthzHandler            authz.Handler
-	ZeusHandler             zeus.Handler
-	QuerierHandler          querier.Handler
-	ServiceAccountHandler   serviceaccount.Handler
-	RegistryHandler         factory.Handler
-	CloudIntegrationHandler cloudintegration.Handler
-	RuleStateHistory        rulestatehistory.Handler
+	SavedView                savedview.Handler
+	Apdex                    apdex.Handler
+	Dashboard                dashboard.Handler
+	QuickFilter              quickfilter.Handler
+	TraceFunnel              tracefunnel.Handler
+	RawDataExport            rawdataexport.Handler
+	SpanPercentile           spanpercentile.Handler
+	Services                 services.Handler
+	MetricsExplorer          metricsexplorer.Handler
+	Global                   global.Handler
+	FlaggerHandler           flagger.Handler
+	GatewayHandler           gateway.Handler
+	Fields                   fields.Handler
+	AuthzHandler             authz.Handler
+	ZeusHandler              zeus.Handler
+	QuerierHandler           querier.Handler
+	ServiceAccountHandler    serviceaccount.Handler
+	RegistryHandler          factory.Handler
+	CloudIntegrationHandler  cloudintegration.Handler
+	RuleStateHistory         rulestatehistory.Handler
+	AIO11yPricingRuleHandler aio11ypricingrule.Handler
 }
 
 func NewHandlers(
@@ -90,7 +89,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),

pkg/signoz/module.go

@@ -13,8 +13,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/authdomain"
 	"github.com/SigNoz/signoz/pkg/modules/authdomain/implauthdomain"
 	"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
 	RuleStateHistory rulestatehistory.Module
@@ -119,7 +116,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:   implserviceaccount.NewModule(implserviceaccount.NewStore(sqlstore), authz, cache, analytics, providerSettings, config.ServiceAccount),
 		RuleStateHistory: implrulestatehistory.NewModule(implrulestatehistory.NewStore(telemetryStore, telemetryMetadataStore, providerSettings.Logger)),

pkg/signoz/openapi.go

@@ -16,12 +16,12 @@ import (
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/http/handler"
 	"github.com/SigNoz/signoz/pkg/instrumentation"
+	"github.com/SigNoz/signoz/pkg/modules/aio11ypricingrule"
 	"github.com/SigNoz/signoz/pkg/modules/authdomain"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"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{ aio11ypricingrule.Handler }{},
 	).New(ctx, instrumentation.ToProviderSettings(), apiserver.Config{})
 	if err != nil {
 		return nil, err

pkg/signoz/provider.go

@@ -3,8 +3,6 @@ package signoz
 import (
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager"
-	"github.com/SigNoz/signoz/pkg/auditor"
-	"github.com/SigNoz/signoz/pkg/auditor/noopauditor"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager/rulebasednotification"
 	"github.com/SigNoz/signoz/pkg/alertmanager/signozalertmanager"
 	"github.com/SigNoz/signoz/pkg/analytics"
@@ -12,6 +10,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/analytics/segmentanalytics"
 	"github.com/SigNoz/signoz/pkg/apiserver"
 	"github.com/SigNoz/signoz/pkg/apiserver/signozapiserver"
+	"github.com/SigNoz/signoz/pkg/auditor"
+	"github.com/SigNoz/signoz/pkg/auditor/noopauditor"
 	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/cache/memorycache"
@@ -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.AIO11yPricingRuleHandler,
 		),
 	)
 }

pkg/types/aio11ypricingruletypes/errors.go

@@ -0,0 +1,9 @@
+package aio11ypricingruletypes
+
+import "github.com/SigNoz/signoz/pkg/errors"
+
+var (
+	ErrCodePricingRuleNotFound      = errors.MustNewCode("pricing_rule_not_found")
+	ErrCodePricingRuleAlreadyExists = errors.MustNewCode("pricing_rule_already_exists")
+	ErrCodePricingRuleInvalidInput  = errors.MustNewCode("pricing_rule_invalid_input")
+)

pkg/types/aio11ypricingruletypes/http.go

@@ -0,0 +1,91 @@
+package aio11ypricingruletypes
+
+import "time"
+
+// GettablePricingRule is the HTTP response representation of a pricing rule.
+type GettablePricingRule struct {
+	ID             string     `json:"id"               required:"true"`
+	Model          string     `json:"model_name"       required:"true"`
+	ModelPattern   []string   `json:"model_pattern"    required:"true"`
+	Unit           Unit       `json:"unit"             required:"true"`
+	CacheMode      CacheMode  `json:"cache_mode"       required:"true"`
+	CostInput      float64    `json:"cost_input"       required:"true"`
+	CostOutput     float64    `json:"cost_output"      required:"true"`
+	CostCacheRead  float64    `json:"cost_cache_read"  required:"true"`
+	CostCacheWrite float64    `json:"cost_cache_write" required:"true"`
+	IsOverride     bool       `json:"is_override"      required:"true"`
+	SyncedAt       *time.Time `json:"synced_at,omitempty"`
+	Enabled        bool       `json:"enabled"          required:"true"`
+	CreatedAt      time.Time  `json:"created_at"       required:"true"`
+	UpdatedAt      time.Time  `json:"updated_at"       required:"true"`
+	CreatedBy      string     `json:"created_by"       required:"true"`
+	UpdatedBy      string     `json:"updated_by"       required:"true"`
+}
+
+// NewGettablePricingRule converts a domain PricingRule to a GettablePricingRule.
+func NewGettablePricingRule(r *PricingRule) *GettablePricingRule {
+	pattern := make([]string, len(r.ModelPattern))
+	copy(pattern, r.ModelPattern)
+
+	return &GettablePricingRule{
+		ID:             r.ID,
+		Model:          r.Model,
+		ModelPattern:   pattern,
+		Unit:           r.Unit,
+		CacheMode:      r.CacheMode,
+		CostInput:      r.CostInput,
+		CostOutput:     r.CostOutput,
+		CostCacheRead:  r.CostCacheRead,
+		CostCacheWrite: r.CostCacheWrite,
+		IsOverride:     r.IsOverride,
+		SyncedAt:       r.SyncedAt,
+		Enabled:        r.Enabled,
+		CreatedAt:      r.CreatedAt,
+		UpdatedAt:      r.UpdatedAt,
+		CreatedBy:      r.CreatedBy,
+		UpdatedBy:      r.UpdatedBy,
+	}
+}
+
+// PostablePricingRule is the HTTP request body for creating a pricing rule.
+// All fields are required.
+type PostablePricingRule struct {
+	Model          string    `json:"model_name"       required:"true"`
+	ModelPattern   []string  `json:"model_pattern"    required:"true"`
+	Unit           Unit      `json:"unit"             required:"true"`
+	CacheMode      CacheMode `json:"cache_mode"       required:"true"`
+	CostInput      float64   `json:"cost_input"       required:"true"`
+	CostOutput     float64   `json:"cost_output"      required:"true"`
+	CostCacheRead  float64   `json:"cost_cache_read"  required:"true"`
+	CostCacheWrite float64   `json:"cost_cache_write" required:"true"`
+	Enabled        bool      `json:"enabled"          required:"true"`
+}
+
+// UpdatablePricingRule is the HTTP request body for updating a pricing rule.
+// All fields are optional; only non-nil fields are applied.
+type UpdatablePricingRule struct {
+	Model          *string    `json:"model_name,omitempty"`
+	ModelPattern   []string   `json:"model_pattern,omitempty"`
+	Unit           *Unit      `json:"unit,omitempty"`
+	CacheMode      *CacheMode `json:"cache_mode,omitempty"`
+	CostInput      *float64   `json:"cost_input,omitempty"`
+	CostOutput     *float64   `json:"cost_output,omitempty"`
+	CostCacheRead  *float64   `json:"cost_cache_read,omitempty"`
+	CostCacheWrite *float64   `json:"cost_cache_write,omitempty"`
+	IsOverride     *bool      `json:"is_override,omitempty"`
+	Enabled        *bool      `json:"enabled,omitempty"`
+}
+
+// ListPricingRulesQuery holds the pagination parameters for listing pricing rules.
+type ListPricingRulesQuery struct {
+	Offset int `query:"offset" json:"offset"`
+	Limit  int `query:"limit"  json:"limit"`
+}
+
+// ListPricingRulesResponse is the paginated response for listing pricing rules.
+type ListPricingRulesResponse struct {
+	Items  []*GettablePricingRule `json:"items"  required:"true" nullable:"true"`
+	Total  int                    `json:"total"  required:"true"`
+	Offset int                    `json:"offset" required:"true"`
+	Limit  int                    `json:"limit"  required:"true"`
+}

pkg/types/aio11ypricingruletypes/pricing.go

@@ -0,0 +1,80 @@
+package aio11ypricingruletypes
+
+import (
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type Unit string
+
+const (
+	UnitPerMillionTokens Unit = "per_million_tokens"
+)
+
+func (Unit) Enum() []any {
+	return []any{UnitPerMillionTokens}
+}
+
+type CacheMode string
+
+const (
+	// CacheModeSubtract: cached tokens are inside input_tokens (OpenAI-style).
+	CacheModeSubtract CacheMode = "subtract"
+	// CacheModeAdditive: cached tokens are reported separately (Anthropic-style).
+	CacheModeAdditive CacheMode = "additive"
+	// CacheModeUnknown: provider behaviour is unknown; falls back to subtract.
+	CacheModeUnknown CacheMode = "unknown"
+)
+
+func (CacheMode) Enum() []any {
+	return []any{CacheModeSubtract, CacheModeAdditive, CacheModeUnknown}
+}
+
+// PricingRule is the domain model for an LLM pricing rule.
+// It has no serialisation concerns — use GettablePricingRule for HTTP responses.
+type PricingRule struct {
+	types.TimeAuditable
+	types.UserAuditable
+
+	ID             string
+	OrgID          valuer.UUID
+	Model          string
+	ModelPattern   []string
+	Unit           Unit
+	CacheMode      CacheMode
+	CostInput      float64
+	CostOutput     float64
+	CostCacheRead  float64
+	CostCacheWrite float64
+	// IsOverride marks that cost fields were manually edited.
+	// When true the sync job skips this rule.
+	IsOverride bool
+	SyncedAt   *time.Time
+	Enabled    bool
+}
+
+// NewPricingRuleFromStorable converts a StorablePricingRule to a PricingRule.
+func NewPricingRuleFromStorable(s *StorablePricingRule) *PricingRule {
+	pattern := make([]string, len(s.ModelPattern))
+	copy(pattern, s.ModelPattern)
+
+	return &PricingRule{
+		TimeAuditable:  s.TimeAuditable,
+		UserAuditable:  s.UserAuditable,
+		ID:             s.ID.StringValue(),
+		OrgID:          s.OrgID,
+		Model:          s.Model,
+		ModelPattern:   pattern,
+		Unit:           s.Unit,
+		CacheMode:      s.CacheMode,
+		CostInput:      s.CostInput,
+		CostOutput:     s.CostOutput,
+		CostCacheRead:  s.CostCacheRead,
+		CostCacheWrite: s.CostCacheWrite,
+		IsOverride:     s.IsOverride,
+		SyncedAt:       s.SyncedAt,
+		Enabled:        s.Enabled,
+	}
+}

pkg/types/aio11ypricingruletypes/storable.go

@@ -0,0 +1,70 @@
+package aio11ypricingruletypes
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/uptrace/bun"
+)
+
+// StringSlice is a []string that is stored as a JSON text column.
+// It is compatible with both SQLite and PostgreSQL.
+type StringSlice []string
+
+func (s StringSlice) Value() (driver.Value, error) {
+	if s == nil {
+		return "[]", nil
+	}
+	b, err := json.Marshal(s)
+	if err != nil {
+		return nil, err
+	}
+	return string(b), nil
+}
+
+func (s *StringSlice) Scan(src any) error {
+	var raw []byte
+	switch v := src.(type) {
+	case string:
+		raw = []byte(v)
+	case []byte:
+		raw = v
+	case nil:
+		*s = nil
+		return nil
+	default:
+		return fmt.Errorf("aio11ypricingruletypes: cannot scan %T into StringSlice", src)
+	}
+	return json.Unmarshal(raw, s)
+}
+
+// StorablePricingRule is the bun/DB representation of an LLM pricing rule.
+type StorablePricingRule struct {
+	bun.BaseModel `bun:"table:llm_pricing_rules,alias:llm_pricing_rules"`
+
+	types.Identifiable
+	types.TimeAuditable
+	types.UserAuditable
+
+	OrgID          valuer.UUID `bun:"org_id,type:text,notnull"`
+	Model          string      `bun:"model,type:text,notnull"`
+	ModelPattern   StringSlice `bun:"model_pattern,type:text,notnull"`
+	Unit           Unit        `bun:"unit,type:text,notnull"`
+	CacheMode      CacheMode   `bun:"cache_mode,type:text,notnull"`
+	CostInput      float64     `bun:"cost_input,notnull"`
+	CostOutput     float64     `bun:"cost_output,notnull"`
+	CostCacheRead  float64     `bun:"cost_cache_read,notnull"`
+	CostCacheWrite float64     `bun:"cost_cache_write,notnull"`
+	// IsOverride marks that cost fields were manually edited.
+	// When true the sync job skips this rule.
+	IsOverride bool `bun:"is_override,notnull,default:false"`
+	// SourceConfig holds the last upstream pricing snapshot; used to revert
+	// when IsOverride is cleared.
+	SourceConfig string     `bun:"source_config,type:text,notnull,default:'{}'"`
+	SyncedAt     *time.Time `bun:"synced_at"`
+	Enabled      bool       `bun:"enabled,notnull,default:true"`
+}

pkg/types/aio11ypricingruletypes/store.go

@@ -0,0 +1,19 @@
+package aio11ypricingruletypes
+
+import (
+	"context"
+
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type Store interface {
+	List(ctx context.Context, orgID valuer.UUID, offset, limit int) ([]*StorablePricingRule, int, error)
+
+	Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*StorablePricingRule, error)
+
+	Create(ctx context.Context, rule *StorablePricingRule) error
+
+	Update(ctx context.Context, rule *StorablePricingRule) error
+
+	Delete(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
+}

pkg/types/cloudintegrationtypes/service.go

@@ -62,6 +62,10 @@ type GettableServicesMetadata struct {
 	Services []*ServiceMetadata `json:"services" required:"true" nullable:"false"`
 }
 
+type ListServicesMetadataParams struct {
+	CloudIntegrationID valuer.UUID `query:"cloud_integration_id" required:"false"`
+}
+
 // Service represents a cloud integration service with its definition,
 // cloud integration service is non nil only when the service entry exists in DB with ANY config (enabled or disabled).
 type Service struct {
@@ -69,6 +73,10 @@ type Service struct {
 	CloudIntegrationService *CloudIntegrationService `json:"cloudIntegrationService" required:"true" nullable:"true"`
 }
 
+type GetServiceParams struct {
+	CloudIntegrationID valuer.UUID `query:"cloud_integration_id" required:"false"`
+}
+
 type UpdatableService struct {
 	Config *ServiceConfig `json:"config" required:"true" nullable:"false"`
 }

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,145 +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 HostsListRequest struct {
-	Start          int64                `json:"start"`
-	End            int64                `json:"end"`
-	Filter         *qbtypes.Filter      `json:"filter"`
-	FilterByStatus HostStatus           `json:"filterByStatus"`
-	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.FilterByStatus.IsZero() && req.FilterByStatus != HostStatusActive && req.FilterByStatus != HostStatusInactive {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid filter by status: %s", req.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,
-				FilterByStatus: HostStatusActive,
-			},
-			wantErr: false,
-		},
-		{
-			name: "filter by status INACTIVE",
-			req: &HostsListRequest{
-				Start:          1000,
-				End:            2000,
-				Limit:          100,
-				Offset:         0,
-				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,
-				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)
-			}
-		})
-	}
-}