feat: adding tests for cloudintegration api

docs/api/openapi.yml

@@ -607,178 +607,6 @@ paths:
       summary: Update auth domain
       tags:
       - authdomains
-  /api/v1/fields/keys:
-    get:
-      deprecated: false
-      description: This endpoint returns field keys
-      operationId: GetFieldsKeys
-      parameters:
-      - in: query
-        name: signal
-        schema:
-          type: string
-      - in: query
-        name: source
-        schema:
-          type: string
-      - in: query
-        name: limit
-        schema:
-          type: integer
-      - in: query
-        name: startUnixMilli
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: endUnixMilli
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: fieldContext
-        schema:
-          type: string
-      - in: query
-        name: fieldDataType
-        schema:
-          type: string
-      - in: query
-        name: metricName
-        schema:
-          type: string
-      - in: query
-        name: searchText
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/TelemetrytypesGettableFieldKeys'
-                  status:
-                    type: string
-                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
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: Get field keys
-      tags:
-      - fields
-  /api/v1/fields/values:
-    get:
-      deprecated: false
-      description: This endpoint returns field values
-      operationId: GetFieldsValues
-      parameters:
-      - in: query
-        name: signal
-        schema:
-          type: string
-      - in: query
-        name: source
-        schema:
-          type: string
-      - in: query
-        name: limit
-        schema:
-          type: integer
-      - in: query
-        name: startUnixMilli
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: endUnixMilli
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: fieldContext
-        schema:
-          type: string
-      - in: query
-        name: fieldDataType
-        schema:
-          type: string
-      - in: query
-        name: metricName
-        schema:
-          type: string
-      - in: query
-        name: searchText
-        schema:
-          type: string
-      - in: query
-        name: name
-        schema:
-          type: string
-      - in: query
-        name: existingQuery
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/TelemetrytypesGettableFieldValues'
-                  status:
-                    type: string
-                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
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: Get field values
-      tags:
-      - fields
   /api/v1/getResetPasswordToken/{id}:
     get:
       deprecated: false
@@ -4100,9 +3928,19 @@ components:
         isMonotonic:
           type: boolean
         temporality:
-          $ref: '#/components/schemas/MetrictypesTemporality'
+          enum:
+          - delta
+          - cumulative
+          - unspecified
+          type: string
         type:
-          $ref: '#/components/schemas/MetrictypesType'
+          enum:
+          - gauge
+          - sum
+          - histogram
+          - summary
+          - exponentialhistogram
+          type: string
         unit:
           type: string
       required:
@@ -4125,7 +3963,13 @@ components:
           minimum: 0
           type: integer
         type:
-          $ref: '#/components/schemas/MetrictypesType'
+          enum:
+          - gauge
+          - sum
+          - histogram
+          - summary
+          - exponentialhistogram
+          type: string
         unit:
           type: string
       required:
@@ -4186,11 +4030,6 @@ components:
       - percentage
       - totalValue
       type: object
-    MetricsexplorertypesTreemapMode:
-      enum:
-      - timeseries
-      - samples
-      type: string
     MetricsexplorertypesTreemapRequest:
       properties:
         end:
@@ -4201,7 +4040,10 @@ components:
         limit:
           type: integer
         mode:
-          $ref: '#/components/schemas/MetricsexplorertypesTreemapMode'
+          enum:
+          - timeseries
+          - samples
+          type: string
         start:
           format: int64
           type: integer
@@ -4236,9 +4078,19 @@ components:
         metricName:
           type: string
         temporality:
-          $ref: '#/components/schemas/MetrictypesTemporality'
+          enum:
+          - delta
+          - cumulative
+          - unspecified
+          type: string
         type:
-          $ref: '#/components/schemas/MetrictypesType'
+          enum:
+          - gauge
+          - sum
+          - histogram
+          - summary
+          - exponentialhistogram
+          type: string
         unit:
           type: string
       required:
@@ -4249,20 +4101,6 @@ components:
       - temporality
       - isMonotonic
       type: object
-    MetrictypesTemporality:
-      enum:
-      - delta
-      - cumulative
-      - unspecified
-      type: string
-    MetrictypesType:
-      enum:
-      - gauge
-      - sum
-      - histogram
-      - summary
-      - exponentialhistogram
-      type: string
     PreferencetypesPreference:
       properties:
         allowedScopes:
@@ -4416,60 +4254,6 @@ components:
           format: date-time
           type: string
       type: object
-    TelemetrytypesGettableFieldKeys:
-      properties:
-        complete:
-          type: boolean
-        keys:
-          additionalProperties:
-            items:
-              $ref: '#/components/schemas/TelemetrytypesTelemetryFieldKey'
-            type: array
-          nullable: true
-          type: object
-      type: object
-    TelemetrytypesGettableFieldValues:
-      properties:
-        complete:
-          type: boolean
-        values:
-          $ref: '#/components/schemas/TelemetrytypesTelemetryFieldValues'
-      type: object
-    TelemetrytypesTelemetryFieldKey:
-      properties:
-        description:
-          type: string
-        fieldContext:
-          type: string
-        fieldDataType:
-          type: string
-        name:
-          type: string
-        signal:
-          type: string
-        unit:
-          type: string
-      type: object
-    TelemetrytypesTelemetryFieldValues:
-      properties:
-        boolValues:
-          items:
-            type: boolean
-          type: array
-        numberValues:
-          items:
-            format: double
-            type: number
-          type: array
-        relatedValues:
-          items:
-            type: string
-          type: array
-        stringValues:
-          items:
-            type: string
-          type: array
-      type: object
     TypesChangePasswordRequest:
       properties:
         newPassword:

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

@@ -9,6 +9,7 @@ import (
 	"github.com/SigNoz/signoz/ee/query-service/integrations/gateway"
 	"github.com/SigNoz/signoz/ee/query-service/usage"
 	"github.com/SigNoz/signoz/pkg/alertmanager"
+	"github.com/SigNoz/signoz/pkg/apis/fields"
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	querierAPI "github.com/SigNoz/signoz/pkg/querier"
@@ -55,6 +56,7 @@ func NewAPIHandler(opts APIHandlerOptions, signoz *signoz.SigNoz) (*APIHandler,
 		FluxInterval:                  opts.FluxInterval,
 		AlertmanagerAPI:               alertmanager.NewAPI(signoz.Alertmanager),
 		LicensingAPI:                  httplicensing.NewLicensingAPI(signoz.Licensing),
+		FieldsAPI:                     fields.NewAPI(signoz.Instrumentation.ToProviderSettings(), signoz.TelemetryStore),
 		Signoz:                        signoz,
 		QuerierAPI:                    querierAPI.NewAPI(signoz.Instrumentation.ToProviderSettings(), signoz.Querier, signoz.Analytics),
 		QueryParserAPI:                queryparser.NewAPI(signoz.Instrumentation.ToProviderSettings(), signoz.QueryParser),

ee/query-service/app/server.go

@@ -237,6 +237,7 @@ func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*h
 	apiHandler.RegisterLogsRoutes(r, am)
 	apiHandler.RegisterIntegrationRoutes(r, am)
 	apiHandler.RegisterCloudIntegrationsRoutes(r, am)
+	apiHandler.RegisterFieldsRoutes(r, am)
 	apiHandler.RegisterQueryRangeV3Routes(r, am)
 	apiHandler.RegisterInfraMetricsRoutes(r, am)
 	apiHandler.RegisterQueryRangeV4Routes(r, am)

frontend/src/api/generated/services/sigNoz.schemas.ts

@@ -762,6 +762,18 @@ export interface MetricsexplorertypesMetricHighlightsResponseDTO {
 	totalTimeSeries: number;
 }
 
+export enum MetricsexplorertypesMetricMetadataDTOTemporality {
+	delta = 'delta',
+	cumulative = 'cumulative',
+	unspecified = 'unspecified',
+}
+export enum MetricsexplorertypesMetricMetadataDTOType {
+	gauge = 'gauge',
+	sum = 'sum',
+	histogram = 'histogram',
+	summary = 'summary',
+	exponentialhistogram = 'exponentialhistogram',
+}
 export interface MetricsexplorertypesMetricMetadataDTO {
 	/**
 	 * @type string
@@ -771,14 +783,29 @@ export interface MetricsexplorertypesMetricMetadataDTO {
 	 * @type boolean
 	 */
 	isMonotonic: boolean;
-	temporality: MetrictypesTemporalityDTO;
-	type: MetrictypesTypeDTO;
+	/**
+	 * @enum delta,cumulative,unspecified
+	 * @type string
+	 */
+	temporality: MetricsexplorertypesMetricMetadataDTOTemporality;
+	/**
+	 * @enum gauge,sum,histogram,summary,exponentialhistogram
+	 * @type string
+	 */
+	type: MetricsexplorertypesMetricMetadataDTOType;
 	/**
 	 * @type string
 	 */
 	unit: string;
 }
 
+export enum MetricsexplorertypesStatDTOType {
+	gauge = 'gauge',
+	sum = 'sum',
+	histogram = 'histogram',
+	summary = 'summary',
+	exponentialhistogram = 'exponentialhistogram',
+}
 export interface MetricsexplorertypesStatDTO {
 	/**
 	 * @type string
@@ -798,7 +825,11 @@ export interface MetricsexplorertypesStatDTO {
 	 * @minimum 0
 	 */
 	timeseries: number;
-	type: MetrictypesTypeDTO;
+	/**
+	 * @enum gauge,sum,histogram,summary,exponentialhistogram
+	 * @type string
+	 */
+	type: MetricsexplorertypesStatDTOType;
 	/**
 	 * @type string
 	 */
@@ -858,7 +889,7 @@ export interface MetricsexplorertypesTreemapEntryDTO {
 	totalValue: number;
 }
 
-export enum MetricsexplorertypesTreemapModeDTO {
+export enum MetricsexplorertypesTreemapRequestDTOMode {
 	timeseries = 'timeseries',
 	samples = 'samples',
 }
@@ -873,7 +904,11 @@ export interface MetricsexplorertypesTreemapRequestDTO {
 	 * @type integer
 	 */
 	limit: number;
-	mode: MetricsexplorertypesTreemapModeDTO;
+	/**
+	 * @enum timeseries,samples
+	 * @type string
+	 */
+	mode: MetricsexplorertypesTreemapRequestDTOMode;
 	/**
 	 * @type integer
 	 * @format int64
@@ -894,6 +929,18 @@ export interface MetricsexplorertypesTreemapResponseDTO {
 	timeseries: MetricsexplorertypesTreemapEntryDTO[] | null;
 }
 
+export enum MetricsexplorertypesUpdateMetricMetadataRequestDTOTemporality {
+	delta = 'delta',
+	cumulative = 'cumulative',
+	unspecified = 'unspecified',
+}
+export enum MetricsexplorertypesUpdateMetricMetadataRequestDTOType {
+	gauge = 'gauge',
+	sum = 'sum',
+	histogram = 'histogram',
+	summary = 'summary',
+	exponentialhistogram = 'exponentialhistogram',
+}
 export interface MetricsexplorertypesUpdateMetricMetadataRequestDTO {
 	/**
 	 * @type string
@@ -907,26 +954,22 @@ export interface MetricsexplorertypesUpdateMetricMetadataRequestDTO {
 	 * @type string
 	 */
 	metricName: string;
-	temporality: MetrictypesTemporalityDTO;
-	type: MetrictypesTypeDTO;
+	/**
+	 * @enum delta,cumulative,unspecified
+	 * @type string
+	 */
+	temporality: MetricsexplorertypesUpdateMetricMetadataRequestDTOTemporality;
+	/**
+	 * @enum gauge,sum,histogram,summary,exponentialhistogram
+	 * @type string
+	 */
+	type: MetricsexplorertypesUpdateMetricMetadataRequestDTOType;
 	/**
 	 * @type string
 	 */
 	unit: string;
 }
 
-export enum MetrictypesTemporalityDTO {
-	delta = 'delta',
-	cumulative = 'cumulative',
-	unspecified = 'unspecified',
-}
-export enum MetrictypesTypeDTO {
-	gauge = 'gauge',
-	sum = 'sum',
-	histogram = 'histogram',
-	summary = 'summary',
-	exponentialhistogram = 'exponentialhistogram',
-}
 export interface PreferencetypesPreferenceDTO {
 	/**
 	 * @type array
@@ -1345,7 +1388,7 @@ export interface TypesPostableForgotPasswordDTO {
 	/**
 	 * @type string
 	 */
-	email: string;
+	email?: string;
 	/**
 	 * @type string
 	 */
@@ -1353,7 +1396,7 @@ export interface TypesPostableForgotPasswordDTO {
 	/**
 	 * @type string
 	 */
-	orgId: string;
+	orgId?: string;
 }
 
 export interface TypesPostableInviteDTO {

pkg/apis/fields/api.go

@@ -0,0 +1,127 @@
+package fields
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/SigNoz/signoz/pkg/telemetrylogs"
+	"github.com/SigNoz/signoz/pkg/telemetrymetadata"
+	"github.com/SigNoz/signoz/pkg/telemetrymeter"
+	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/telemetrystore"
+	"github.com/SigNoz/signoz/pkg/telemetrytraces"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+type API struct {
+	telemetryStore         telemetrystore.TelemetryStore
+	telemetryMetadataStore telemetrytypes.MetadataStore
+}
+
+// TODO: move this to module and remove metastore init
+func NewAPI(
+	settings factory.ProviderSettings,
+	telemetryStore telemetrystore.TelemetryStore,
+) *API {
+	telemetryMetadataStore := telemetrymetadata.NewTelemetryMetaStore(
+		settings,
+		telemetryStore,
+		telemetrytraces.DBName,
+		telemetrytraces.TagAttributesV2TableName,
+		telemetrytraces.SpanAttributesKeysTblName,
+		telemetrytraces.SpanIndexV3TableName,
+		telemetrymetrics.DBName,
+		telemetrymetrics.AttributesMetadataTableName,
+		telemetrymeter.DBName,
+		telemetrymeter.SamplesAgg1dTableName,
+		telemetrylogs.DBName,
+		telemetrylogs.LogsV2TableName,
+		telemetrylogs.TagAttributesV2TableName,
+		telemetrylogs.LogAttributeKeysTblName,
+		telemetrylogs.LogResourceKeysTblName,
+		telemetrymetadata.DBName,
+		telemetrymetadata.AttributesMetadataLocalTableName,
+	)
+
+	return &API{
+		telemetryStore:         telemetryStore,
+		telemetryMetadataStore: telemetryMetadataStore,
+	}
+}
+
+func (api *API) GetFieldsKeys(w http.ResponseWriter, r *http.Request) {
+
+	type fieldKeysResponse struct {
+		Keys     map[string][]*telemetrytypes.TelemetryFieldKey `json:"keys"`
+		Complete bool                                           `json:"complete"`
+	}
+
+	bodyBytes, _ := io.ReadAll(r.Body)
+	r.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+	ctx := r.Context()
+
+	fieldKeySelector, err := parseFieldKeyRequest(r)
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	keys, complete, err := api.telemetryMetadataStore.GetKeys(ctx, fieldKeySelector)
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	response := fieldKeysResponse{
+		Keys:     keys,
+		Complete: complete,
+	}
+
+	render.Success(w, http.StatusOK, response)
+}
+
+func (api *API) GetFieldsValues(w http.ResponseWriter, r *http.Request) {
+
+	type fieldValuesResponse struct {
+		Values   *telemetrytypes.TelemetryFieldValues `json:"values"`
+		Complete bool                                 `json:"complete"`
+	}
+
+	bodyBytes, _ := io.ReadAll(r.Body)
+	r.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+	ctx := r.Context()
+
+	fieldValueSelector, err := parseFieldValueRequest(r)
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	allValues, allComplete, err := api.telemetryMetadataStore.GetAllValues(ctx, fieldValueSelector)
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	relatedValues, relatedComplete, err := api.telemetryMetadataStore.GetRelatedValues(ctx, fieldValueSelector)
+	if err != nil {
+		// we don't want to return error if we fail to get related values for some reason
+		relatedValues = []string{}
+	}
+
+	values := &telemetrytypes.TelemetryFieldValues{
+		StringValues:  allValues.StringValues,
+		NumberValues:  allValues.NumberValues,
+		RelatedValues: relatedValues,
+	}
+
+	response := fieldValuesResponse{
+		Values:   values,
+		Complete: allComplete && relatedComplete,
+	}
+
+	render.Success(w, http.StatusOK, response)
+}

pkg/apis/fields/parse.go

@@ -0,0 +1,162 @@
+package fields
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+func parseFieldKeyRequest(r *http.Request) (*telemetrytypes.FieldKeySelector, error) {
+	var req telemetrytypes.FieldKeySelector
+	var signal telemetrytypes.Signal
+	var source telemetrytypes.Source
+	var err error
+
+	signalStr := r.URL.Query().Get("signal")
+	if signalStr != "" {
+		signal = telemetrytypes.Signal{String: valuer.NewString(signalStr)}
+	} else {
+		signal = telemetrytypes.SignalUnspecified
+	}
+
+	sourceStr := r.URL.Query().Get("source")
+	if sourceStr != "" {
+		source = telemetrytypes.Source{String: valuer.NewString(sourceStr)}
+	} else {
+		source = telemetrytypes.SourceUnspecified
+	}
+
+	if r.URL.Query().Get("limit") != "" {
+		limit, err := strconv.Atoi(r.URL.Query().Get("limit"))
+		if err != nil {
+			return nil, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to parse limit")
+		}
+		req.Limit = limit
+	} else {
+		req.Limit = 1000
+	}
+
+	var startUnixMilli, endUnixMilli int64
+
+	if r.URL.Query().Get("startUnixMilli") != "" {
+		startUnixMilli, err = strconv.ParseInt(r.URL.Query().Get("startUnixMilli"), 10, 64)
+		if err != nil {
+			return nil, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to parse startUnixMilli")
+		}
+		// Round down to the nearest 6 hours (21600000 milliseconds)
+		startUnixMilli -= startUnixMilli % 21600000
+	}
+	if r.URL.Query().Get("endUnixMilli") != "" {
+		endUnixMilli, err = strconv.ParseInt(r.URL.Query().Get("endUnixMilli"), 10, 64)
+		if err != nil {
+			return nil, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to parse endUnixMilli")
+		}
+	}
+
+	// Parse fieldContext directly instead of using JSON unmarshalling.
+	var fieldContext telemetrytypes.FieldContext
+	fieldContextStr := r.URL.Query().Get("fieldContext")
+	if fieldContextStr != "" {
+		fieldContext = telemetrytypes.FieldContext{String: valuer.NewString(fieldContextStr)}
+	}
+
+	// Parse fieldDataType directly instead of using JSON unmarshalling.
+	var fieldDataType telemetrytypes.FieldDataType
+	fieldDataTypeStr := r.URL.Query().Get("fieldDataType")
+	if fieldDataTypeStr != "" {
+		fieldDataType = telemetrytypes.FieldDataType{String: valuer.NewString(fieldDataTypeStr)}
+	}
+
+	metricName := r.URL.Query().Get("metricName")
+	var metricContext *telemetrytypes.MetricContext
+	if metricName != "" {
+		metricContext = &telemetrytypes.MetricContext{
+			MetricName: metricName,
+		}
+	}
+
+	name := r.URL.Query().Get("searchText")
+
+	if name != "" && fieldContext == telemetrytypes.FieldContextUnspecified {
+		parsedFieldKey := telemetrytypes.GetFieldKeyFromKeyText(name)
+		if parsedFieldKey.FieldContext != telemetrytypes.FieldContextUnspecified {
+			// Only apply inferred context if it is valid for the current signal
+			if isContextValidForSignal(parsedFieldKey.FieldContext, signal) {
+				name = parsedFieldKey.Name
+				fieldContext = parsedFieldKey.FieldContext
+			}
+		}
+	}
+
+	req = telemetrytypes.FieldKeySelector{
+		StartUnixMilli:    startUnixMilli,
+		EndUnixMilli:      endUnixMilli,
+		Signal:            signal,
+		Source:            source,
+		Name:              name,
+		FieldContext:      fieldContext,
+		FieldDataType:     fieldDataType,
+		Limit:             req.Limit,
+		SelectorMatchType: telemetrytypes.FieldSelectorMatchTypeFuzzy,
+		MetricContext:     metricContext,
+	}
+	return &req, nil
+}
+
+func parseFieldValueRequest(r *http.Request) (*telemetrytypes.FieldValueSelector, error) {
+	keySelector, err := parseFieldKeyRequest(r)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to parse field key request")
+	}
+
+	name := r.URL.Query().Get("name")
+	if name != "" && keySelector.FieldContext == telemetrytypes.FieldContextUnspecified {
+		parsedFieldKey := telemetrytypes.GetFieldKeyFromKeyText(name)
+		if parsedFieldKey.FieldContext != telemetrytypes.FieldContextUnspecified {
+			// Only apply inferred context if it is valid for the current signal
+			if isContextValidForSignal(parsedFieldKey.FieldContext, keySelector.Signal) {
+				name = parsedFieldKey.Name
+				keySelector.FieldContext = parsedFieldKey.FieldContext
+			}
+		}
+	}
+	keySelector.Name = name
+	existingQuery := r.URL.Query().Get("existingQuery")
+	value := r.URL.Query().Get("searchText")
+
+	// Parse limit for fieldValue request, fallback to default 50 if parsing fails.
+	limit, err := strconv.Atoi(r.URL.Query().Get("limit"))
+	if err != nil {
+		limit = 50
+	}
+
+	req := telemetrytypes.FieldValueSelector{
+		FieldKeySelector: keySelector,
+		ExistingQuery:    existingQuery,
+		Value:            value,
+		Limit:            limit,
+	}
+
+	return &req, nil
+}
+
+func isContextValidForSignal(ctx telemetrytypes.FieldContext, signal telemetrytypes.Signal) bool {
+	if ctx == telemetrytypes.FieldContextResource ||
+		ctx == telemetrytypes.FieldContextAttribute ||
+		ctx == telemetrytypes.FieldContextScope {
+		return true
+	}
+
+	switch signal.StringValue() {
+	case telemetrytypes.SignalLogs.StringValue():
+		return ctx == telemetrytypes.FieldContextLog || ctx == telemetrytypes.FieldContextBody
+	case telemetrytypes.SignalTraces.StringValue():
+		return ctx == telemetrytypes.FieldContextSpan || ctx == telemetrytypes.FieldContextEvent || ctx == telemetrytypes.FieldContextTrace
+	case telemetrytypes.SignalMetrics.StringValue():
+		return ctx == telemetrytypes.FieldContextMetric
+	}
+	return true
+}

pkg/apiserver/signozapiserver/fields.go

@@ -1,50 +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/telemetrytypes"
-	"github.com/gorilla/mux"
-)
-
-func (provider *provider) addFieldsRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v1/fields/keys", handler.New(provider.authZ.ViewAccess(provider.fieldsHandler.GetFieldsKeys), handler.OpenAPIDef{
-		ID:                  "GetFieldsKeys",
-		Tags:                []string{"fields"},
-		Summary:             "Get field keys",
-		Description:         "This endpoint returns field keys",
-		Request:             nil,
-		RequestQuery:        new(telemetrytypes.PostableFieldKeysParams),
-		RequestContentType:  "",
-		Response:            new(telemetrytypes.GettableFieldKeys),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/fields/values", handler.New(provider.authZ.ViewAccess(provider.fieldsHandler.GetFieldsValues), handler.OpenAPIDef{
-		ID:                  "GetFieldsValues",
-		Tags:                []string{"fields"},
-		Summary:             "Get field values",
-		Description:         "This endpoint returns field values",
-		Request:             nil,
-		RequestQuery:        new(telemetrytypes.PostableFieldValueParams),
-		RequestContentType:  "",
-		Response:            new(telemetrytypes.GettableFieldValues),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	return nil
-}

pkg/apiserver/signozapiserver/provider.go

@@ -13,7 +13,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	"github.com/SigNoz/signoz/pkg/modules/authdomain"
 	"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/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
@@ -45,7 +44,6 @@ type provider struct {
 	gatewayHandler         gateway.Handler
 	roleGetter             role.Getter
 	roleHandler            role.Handler
-	fieldsHandler          fields.Handler
 }
 
 func NewFactory(
@@ -65,31 +63,9 @@ func NewFactory(
 	gatewayHandler gateway.Handler,
 	roleGetter role.Getter,
 	roleHandler role.Handler,
-	fieldsHandler fields.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(
-			ctx,
-			providerSettings,
-			config,
-			orgGetter,
-			authz,
-			orgHandler,
-			userHandler,
-			sessionHandler,
-			authDomainHandler,
-			preferenceHandler,
-			globalHandler,
-			promoteHandler,
-			flaggerHandler,
-			dashboardModule,
-			dashboardHandler,
-			metricsExplorerHandler,
-			gatewayHandler,
-			roleGetter,
-			roleHandler,
-			fieldsHandler,
-		)
+		return newProvider(ctx, providerSettings, config, orgGetter, authz, orgHandler, userHandler, sessionHandler, authDomainHandler, preferenceHandler, globalHandler, promoteHandler, flaggerHandler, dashboardModule, dashboardHandler, metricsExplorerHandler, gatewayHandler, roleGetter, roleHandler)
 	})
 }
 
@@ -113,7 +89,6 @@ func newProvider(
 	gatewayHandler gateway.Handler,
 	roleGetter role.Getter,
 	roleHandler role.Handler,
-	fieldsHandler fields.Handler,
 ) (apiserver.APIServer, error) {
 	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/apiserver/signozapiserver")
 	router := mux.NewRouter().UseEncodedPath()
@@ -136,7 +111,6 @@ func newProvider(
 		gatewayHandler:         gatewayHandler,
 		roleGetter:             roleGetter,
 		roleHandler:            roleHandler,
-		fieldsHandler:          fieldsHandler,
 	}
 
 	provider.authZ = middleware.NewAuthZ(settings.Logger(), orgGetter, authz, roleGetter)
@@ -201,10 +175,6 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
-	if err := provider.addFieldsRoutes(router); err != nil {
-		return err
-	}
-
 	return nil
 }
 

pkg/modules/fields/handler.go

@@ -1,11 +0,0 @@
-package fields
-
-import "net/http"
-
-type Handler interface {
-	// Gets the fields keys for the given field key selector
-	GetFieldsKeys(http.ResponseWriter, *http.Request)
-
-	// Gets the fields values for the given field value selector
-	GetFieldsValues(http.ResponseWriter, *http.Request)
-}

pkg/modules/fields/implfields/handler.go

@@ -1,79 +0,0 @@
-package implfields
-
-import (
-	"net/http"
-
-	"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/fields"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-)
-
-type handler struct {
-	telemetryMetadataStore telemetrytypes.MetadataStore
-}
-
-func NewHandler(settings factory.ProviderSettings, telemetryMetadataStore telemetrytypes.MetadataStore) fields.Handler {
-	return &handler{
-		telemetryMetadataStore: telemetryMetadataStore,
-	}
-}
-
-func (handler *handler) GetFieldsKeys(rw http.ResponseWriter, req *http.Request) {
-	ctx := req.Context()
-
-	var params telemetrytypes.PostableFieldKeysParams
-	if err := binding.Query.BindQuery(req.URL.Query(), &params); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	fieldKeySelector := telemetrytypes.NewFieldKeySelectorFromPostableFieldKeysParams(params)
-
-	keys, complete, err := handler.telemetryMetadataStore.GetKeys(ctx, fieldKeySelector)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, &telemetrytypes.GettableFieldKeys{
-		Keys:     keys,
-		Complete: complete,
-	})
-}
-
-func (handler *handler) GetFieldsValues(rw http.ResponseWriter, req *http.Request) {
-	ctx := req.Context()
-
-	var params telemetrytypes.PostableFieldValueParams
-	if err := binding.Query.BindQuery(req.URL.Query(), &params); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	fieldValueSelector := telemetrytypes.NewFieldValueSelectorFromPostableFieldValueParams(params)
-
-	allValues, allComplete, err := handler.telemetryMetadataStore.GetAllValues(ctx, fieldValueSelector)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	relatedValues, relatedComplete, err := handler.telemetryMetadataStore.GetRelatedValues(ctx, fieldValueSelector)
-	if err != nil {
-		// we don't want to return error if we fail to get related values for some reason
-		relatedValues = []string{}
-	}
-
-	values := &telemetrytypes.TelemetryFieldValues{
-		StringValues:  allValues.StringValues,
-		NumberValues:  allValues.NumberValues,
-		RelatedValues: relatedValues,
-	}
-
-	render.Success(rw, http.StatusOK, &telemetrytypes.GettableFieldValues{
-		Values:   values,
-		Complete: allComplete && relatedComplete,
-	})
-}

pkg/query-service/app/http_handler.go

@@ -25,6 +25,7 @@ import (
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/alertmanager"
+	"github.com/SigNoz/signoz/pkg/apis/fields"
 	errorsV2 "github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	"github.com/SigNoz/signoz/pkg/http/render"
@@ -144,6 +145,8 @@ type APIHandler struct {
 
 	LicensingAPI licensing.API
 
+	FieldsAPI *fields.API
+
 	QuerierAPI *querierAPI.API
 
 	QueryParserAPI *queryparser.API
@@ -174,6 +177,8 @@ type APIHandlerOpts struct {
 
 	LicensingAPI licensing.API
 
+	FieldsAPI *fields.API
+
 	QuerierAPI *querierAPI.API
 
 	QueryParserAPI *queryparser.API
@@ -238,6 +243,7 @@ func NewAPIHandler(opts APIHandlerOpts) (*APIHandler, error) {
 		AlertmanagerAPI:               opts.AlertmanagerAPI,
 		LicensingAPI:                  opts.LicensingAPI,
 		Signoz:                        opts.Signoz,
+		FieldsAPI:                     opts.FieldsAPI,
 		QuerierAPI:                    opts.QuerierAPI,
 		QueryParserAPI:                opts.QueryParserAPI,
 	}
@@ -393,6 +399,13 @@ func (aH *APIHandler) RegisterQueryRangeV3Routes(router *mux.Router, am *middlew
 	subRouter.HandleFunc("/logs/livetail", am.ViewAccess(aH.QuerierAPI.QueryRawStream)).Methods(http.MethodGet)
 }
 
+func (aH *APIHandler) RegisterFieldsRoutes(router *mux.Router, am *middleware.AuthZ) {
+	subRouter := router.PathPrefix("/api/v1").Subrouter()
+
+	subRouter.HandleFunc("/fields/keys", am.ViewAccess(aH.FieldsAPI.GetFieldsKeys)).Methods(http.MethodGet)
+	subRouter.HandleFunc("/fields/values", am.ViewAccess(aH.FieldsAPI.GetFieldsValues)).Methods(http.MethodGet)
+}
+
 func (aH *APIHandler) RegisterInfraMetricsRoutes(router *mux.Router, am *middleware.AuthZ) {
 	hostsSubRouter := router.PathPrefix("/api/v1/hosts").Subrouter()
 	hostsSubRouter.HandleFunc("/attribute_keys", am.ViewAccess(aH.getHostAttributeKeys)).Methods(http.MethodGet)

pkg/query-service/app/server.go

@@ -17,6 +17,7 @@ import (
 	"github.com/gorilla/handlers"
 
 	"github.com/SigNoz/signoz/pkg/alertmanager"
+	"github.com/SigNoz/signoz/pkg/apis/fields"
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	"github.com/SigNoz/signoz/pkg/licensing/nooplicensing"
@@ -132,6 +133,7 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 		FluxInterval:                  config.Querier.FluxInterval,
 		AlertmanagerAPI:               alertmanager.NewAPI(signoz.Alertmanager),
 		LicensingAPI:                  nooplicensing.NewLicenseAPI(),
+		FieldsAPI:                     fields.NewAPI(signoz.Instrumentation.ToProviderSettings(), signoz.TelemetryStore),
 		Signoz:                        signoz,
 		QuerierAPI:                    querierAPI.NewAPI(signoz.Instrumentation.ToProviderSettings(), signoz.Querier, signoz.Analytics),
 		QueryParserAPI:                queryparser.NewAPI(signoz.Instrumentation.ToProviderSettings(), signoz.QueryParser),
@@ -213,6 +215,7 @@ func (s *Server) createPublicServer(api *APIHandler, web web.Web) (*http.Server,
 	api.RegisterLogsRoutes(r, am)
 	api.RegisterIntegrationRoutes(r, am)
 	api.RegisterCloudIntegrationsRoutes(r, am)
+	api.RegisterFieldsRoutes(r, am)
 	api.RegisterQueryRangeV3Routes(r, am)
 	api.RegisterInfraMetricsRoutes(r, am)
 	api.RegisterWebSocketPaths(r, am)

pkg/signoz/handler.go

@@ -11,8 +11,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/apdex/implapdex"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"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/metricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer/implmetricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/quickfilter"
@@ -30,7 +28,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/tracefunnel"
 	"github.com/SigNoz/signoz/pkg/modules/tracefunnel/impltracefunnel"
 	"github.com/SigNoz/signoz/pkg/querier"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
 
 type Handlers struct {
@@ -47,19 +44,9 @@ type Handlers struct {
 	FlaggerHandler  flagger.Handler
 	GatewayHandler  gateway.Handler
 	Role            role.Handler
-	Fields          fields.Handler
 }
 
-func NewHandlers(
-	modules Modules,
-	providerSettings factory.ProviderSettings,
-	querier querier.Querier,
-	licensing licensing.Licensing,
-	global global.Global,
-	flaggerService flagger.Flagger,
-	gatewayService gateway.Gateway,
-	telemetryMetadataStore telemetrytypes.MetadataStore,
-) Handlers {
+func NewHandlers(modules Modules, providerSettings factory.ProviderSettings, querier querier.Querier, licensing licensing.Licensing, global global.Global, flaggerService flagger.Flagger, gatewayService gateway.Gateway) Handlers {
 	return Handlers{
 		SavedView:       implsavedview.NewHandler(modules.SavedView),
 		Apdex:           implapdex.NewHandler(modules.Apdex),
@@ -74,6 +61,5 @@ func NewHandlers(
 		FlaggerHandler:  flagger.NewHandler(flaggerService),
 		GatewayHandler:  gateway.NewHandler(gatewayService),
 		Role:            implrole.NewHandler(modules.RoleSetter, modules.RoleGetter),
-		Fields:          implfields.NewHandler(providerSettings, telemetryMetadataStore),
 	}
 }

pkg/signoz/handler_test.go

@@ -46,7 +46,7 @@ func TestNewHandlers(t *testing.T) {
 	grantModule := implrole.NewGranter(implrole.NewStore(sqlstore), nil)
 	modules := NewModules(sqlstore, tokenizer, emailing, providerSettings, orgGetter, alertmanager, nil, nil, nil, nil, nil, nil, nil, queryParser, Config{}, dashboardModule, roleSetter, roleGetter, grantModule)
 
-	handlers := NewHandlers(modules, providerSettings, nil, nil, nil, nil, nil, nil)
+	handlers := NewHandlers(modules, providerSettings, nil, nil, nil, nil, nil)
 
 	reflectVal := reflect.ValueOf(handlers)
 	for i := 0; i < reflectVal.NumField(); i++ {

pkg/signoz/openapi.go

@@ -15,7 +15,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/instrumentation"
 	"github.com/SigNoz/signoz/pkg/modules/authdomain"
 	"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/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
@@ -53,7 +52,6 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ gateway.Handler }{},
 		struct{ role.Getter }{},
 		struct{ role.Handler }{},
-		struct{ fields.Handler }{},
 	).New(ctx, instrumentation.ToProviderSettings(), apiserver.Config{})
 	if err != nil {
 		return nil, err

pkg/signoz/provider.go

@@ -249,7 +249,6 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			handlers.GatewayHandler,
 			modules.RoleGetter,
 			handlers.Role,
-			handlers.Fields,
 		),
 	)
 }

pkg/signoz/signoz.go

@@ -396,7 +396,7 @@ func New(
 	modules := NewModules(sqlstore, tokenizer, emailing, providerSettings, orgGetter, alertmanager, analytics, querier, telemetrystore, telemetryMetadataStore, authNs, authz, cache, queryParser, config, dashboard, roleSetter, roleGetter, granter)
 
 	// Initialize all handlers for the modules
-	handlers := NewHandlers(modules, providerSettings, querier, licensing, global, flagger, gateway, telemetryMetadataStore)
+	handlers := NewHandlers(modules, providerSettings, querier, licensing, global, flagger, gateway)
 
 	// Initialize the API server
 	apiserver, err := factory.NewProviderFromNamedMap(

pkg/types/integration.go

@@ -151,7 +151,8 @@ func (c *AccountConfig) Value() (driver.Value, error) {
 	if err != nil {
 		return nil, errors.WrapInternalf(err, errors.CodeInternal, "couldn't serialize cloud account config to JSON")
 	}
-	return serialized, nil
+	// Return as string instead of []byte to ensure PostgreSQL stores as text, not bytea
+	return string(serialized), nil
 }
 
 type AgentReport struct {
@@ -186,7 +187,8 @@ func (r *AgentReport) Value() (driver.Value, error) {
 			err, errors.CodeInternal, "couldn't serialize agent report to JSON",
 		)
 	}
-	return serialized, nil
+	// Return as string instead of []byte to ensure PostgreSQL stores as text, not bytea
+	return string(serialized), nil
 }
 
 type CloudIntegrationService struct {
@@ -240,5 +242,6 @@ func (c *CloudServiceConfig) Value() (driver.Value, error) {
 			err, errors.CodeInternal, "couldn't serialize cloud service config to JSON",
 		)
 	}
-	return serialized, nil
+	// Return as string instead of []byte to ensure PostgreSQL stores as text, not bytea
+	return string(serialized), nil
 }

pkg/types/metricsexplorertypes/metricsexplorer.go

@@ -31,13 +31,6 @@ var (
 	TreemapModeSamples = TreemapMode{valuer.NewString("samples")}
 )
 
-func (TreemapMode) Enum() []any {
-	return []any{
-		TreemapModeTimeSeries,
-		TreemapModeSamples,
-	}
-}
-
 // StatsRequest represents the payload accepted by the metrics stats endpoint.
 type StatsRequest struct {
 	Filter  *qbtypes.Filter  `json:"filter,omitempty"`
@@ -105,7 +98,7 @@ func (req *StatsRequest) UnmarshalJSON(data []byte) error {
 type Stat struct {
 	MetricName  string           `json:"metricName" required:"true"`
 	Description string           `json:"description" required:"true"`
-	MetricType  metrictypes.Type `json:"type" required:"true"`
+	MetricType  metrictypes.Type `json:"type" required:"true" enum:"gauge,sum,histogram,summary,exponentialhistogram"`
 	MetricUnit  string           `json:"unit" required:"true"`
 	TimeSeries  uint64           `json:"timeseries" required:"true"`
 	Samples     uint64           `json:"samples" required:"true"`
@@ -119,9 +112,9 @@ type StatsResponse struct {
 
 type MetricMetadata struct {
 	Description string                  `json:"description" required:"true"`
-	MetricType  metrictypes.Type        `json:"type" required:"true"`
+	MetricType  metrictypes.Type        `json:"type" required:"true" enum:"gauge,sum,histogram,summary,exponentialhistogram"`
 	MetricUnit  string                  `json:"unit" required:"true"`
-	Temporality metrictypes.Temporality `json:"temporality" required:"true"`
+	Temporality metrictypes.Temporality `json:"temporality" required:"true" enum:"delta,cumulative,unspecified"`
 	IsMonotonic bool                    `json:"isMonotonic" required:"true"`
 }
 
@@ -138,10 +131,10 @@ func (m *MetricMetadata) UnmarshalBinary(data []byte) error {
 // UpdateMetricMetadataRequest represents the payload for updating metric metadata.
 type UpdateMetricMetadataRequest struct {
 	MetricName  string                  `json:"metricName" required:"true"`
-	Type        metrictypes.Type        `json:"type" required:"true"`
+	Type        metrictypes.Type        `json:"type" required:"true" enum:"gauge,sum,histogram,summary,exponentialhistogram"`
 	Description string                  `json:"description" required:"true"`
 	Unit        string                  `json:"unit" required:"true"`
-	Temporality metrictypes.Temporality `json:"temporality" required:"true"`
+	Temporality metrictypes.Temporality `json:"temporality" required:"true" enum:"delta,cumulative,unspecified"`
 	IsMonotonic bool                    `json:"isMonotonic" required:"true"`
 }
 
@@ -151,7 +144,7 @@ type TreemapRequest struct {
 	Start  int64           `json:"start" required:"true"`
 	End    int64           `json:"end" required:"true"`
 	Limit  int             `json:"limit" required:"true"`
-	Mode   TreemapMode     `json:"mode" required:"true"`
+	Mode   TreemapMode     `json:"mode" required:"true" enum:"timeseries,samples"`
 }
 
 // Validate enforces basic constraints on TreemapRequest.

pkg/types/metrictypes/metrictypes.go

@@ -36,7 +36,7 @@ func (t Temporality) Value() (driver.Value, error) {
 	}
 }
 
-func (t *Temporality) Scan(src any) error {
+func (t *Temporality) Scan(src interface{}) error {
 	if src == nil {
 		*t = Unknown
 		return nil
@@ -66,14 +66,6 @@ func (t *Temporality) Scan(src any) error {
 	return nil
 }
 
-func (Temporality) Enum() []any {
-	return []any{
-		Delta,
-		Cumulative,
-		Unspecified,
-	}
-}
-
 // Type is the type of the metric in OTLP data model
 // Read more here https://opentelemetry.io/docs/specs/otel/metrics/data-model/#metric-points
 type Type struct {
@@ -142,16 +134,6 @@ var (
 	UnspecifiedType  = Type{valuer.NewString("")}
 )
 
-func (Type) Enum() []any {
-	return []any{
-		GaugeType,
-		SumType,
-		HistogramType,
-		SummaryType,
-		ExpHistogramType,
-	}
-}
-
 type TimeAggregation struct {
 	valuer.String
 }
@@ -169,21 +151,6 @@ var (
 	TimeAggregationIncrease      = TimeAggregation{valuer.NewString("increase")}
 )
 
-func (TimeAggregation) Enum() []any {
-	return []any{
-		TimeAggregationUnspecified,
-		TimeAggregationLatest,
-		TimeAggregationSum,
-		TimeAggregationAvg,
-		TimeAggregationMin,
-		TimeAggregationMax,
-		TimeAggregationCount,
-		TimeAggregationCountDistinct,
-		TimeAggregationRate,
-		TimeAggregationIncrease,
-	}
-}
-
 type SpaceAggregation struct {
 	valuer.String
 }
@@ -202,22 +169,6 @@ var (
 	SpaceAggregationPercentile99 = SpaceAggregation{valuer.NewString("p99")}
 )
 
-func (SpaceAggregation) Enum() []any {
-	return []any{
-		SpaceAggregationUnspecified,
-		SpaceAggregationSum,
-		SpaceAggregationAvg,
-		SpaceAggregationMin,
-		SpaceAggregationMax,
-		SpaceAggregationCount,
-		SpaceAggregationPercentile50,
-		SpaceAggregationPercentile75,
-		SpaceAggregationPercentile90,
-		SpaceAggregationPercentile95,
-		SpaceAggregationPercentile99,
-	}
-}
-
 func (s SpaceAggregation) IsPercentile() bool {
 	return s == SpaceAggregationPercentile50 ||
 		s == SpaceAggregationPercentile75 ||

pkg/types/telemetrytypes/field.go

@@ -266,110 +266,3 @@ type FieldValueSelector struct {
 	Value         string `json:"value"`
 	Limit         int    `json:"limit"`
 }
-
-type GettableFieldKeys struct {
-	Keys     map[string][]*TelemetryFieldKey `json:"keys"`
-	Complete bool                            `json:"complete"`
-}
-
-type PostableFieldKeysParams struct {
-	Signal         Signal        `query:"signal"`
-	Source         Source        `query:"source"`
-	Limit          int           `query:"limit"`
-	StartUnixMilli int64         `query:"startUnixMilli"`
-	EndUnixMilli   int64         `query:"endUnixMilli"`
-	FieldContext   FieldContext  `query:"fieldContext"`
-	FieldDataType  FieldDataType `query:"fieldDataType"`
-	MetricName     string        `query:"metricName"`
-	SearchText     string        `query:"searchText"`
-}
-
-type GettableFieldValues struct {
-	Values   *TelemetryFieldValues `json:"values"`
-	Complete bool                  `json:"complete"`
-}
-
-type PostableFieldValueParams struct {
-	PostableFieldKeysParams
-	Name          string `query:"name"`
-	ExistingQuery string `query:"existingQuery"`
-}
-
-func NewFieldKeySelectorFromPostableFieldKeysParams(params PostableFieldKeysParams) *FieldKeySelector {
-	var req FieldKeySelector
-
-	if params.StartUnixMilli != 0 {
-		req.StartUnixMilli = params.StartUnixMilli
-		// Round down to the nearest 6 hours (21600000 milliseconds)
-		req.StartUnixMilli -= req.StartUnixMilli % 21600000
-	}
-
-	if params.EndUnixMilli != 0 {
-		req.EndUnixMilli = params.EndUnixMilli
-	}
-
-	req.Signal = params.Signal
-	req.Source = params.Source
-	req.FieldContext = params.FieldContext
-	req.FieldDataType = params.FieldDataType
-	req.SelectorMatchType = FieldSelectorMatchTypeFuzzy
-
-	if params.Limit != 0 {
-		req.Limit = params.Limit
-	} else {
-		req.Limit = 1000
-	}
-
-	if params.MetricName != "" {
-		req.MetricContext = &MetricContext{
-			MetricName: params.MetricName,
-		}
-	}
-
-	req.Name = params.SearchText
-	if params.SearchText != "" && params.FieldContext == FieldContextUnspecified {
-		parsedFieldKey := GetFieldKeyFromKeyText(params.SearchText)
-		if parsedFieldKey.FieldContext != FieldContextUnspecified {
-			// Only apply inferred context if it is valid for the current signal
-			if isContextValidForSignal(parsedFieldKey.FieldContext, req.Signal) {
-				req.Name = parsedFieldKey.Name
-				req.FieldContext = parsedFieldKey.FieldContext
-			}
-		}
-	}
-
-	return &req
-}
-
-func NewFieldValueSelectorFromPostableFieldValueParams(params PostableFieldValueParams) *FieldValueSelector {
-
-	keySelector := NewFieldKeySelectorFromPostableFieldKeysParams(params.PostableFieldKeysParams)
-
-	fieldValueSelector := &FieldValueSelector{
-		FieldKeySelector: keySelector,
-	}
-
-	fieldValueSelector.Name = params.Name
-
-	if params.Name != "" && fieldValueSelector.FieldContext == FieldContextUnspecified {
-		parsedFieldKey := GetFieldKeyFromKeyText(params.Name)
-		if parsedFieldKey.FieldContext != FieldContextUnspecified {
-			// Only apply inferred context if it is valid for the current signal
-			if isContextValidForSignal(parsedFieldKey.FieldContext, fieldValueSelector.Signal) {
-				fieldValueSelector.Name = parsedFieldKey.Name
-				fieldValueSelector.FieldContext = parsedFieldKey.FieldContext
-			}
-		}
-	}
-
-	fieldValueSelector.ExistingQuery = params.ExistingQuery
-	fieldValueSelector.Value = params.SearchText
-
-	if params.Limit != 0 {
-		fieldValueSelector.Limit = params.Limit
-	} else {
-		fieldValueSelector.Limit = 50
-	}
-
-	return fieldValueSelector
-}

pkg/types/telemetrytypes/field_context.go

@@ -154,21 +154,3 @@ func (f FieldContext) TagType() string {
 	}
 	return ""
 }
-
-func isContextValidForSignal(ctx FieldContext, signal Signal) bool {
-	if ctx == FieldContextResource ||
-		ctx == FieldContextAttribute ||
-		ctx == FieldContextScope {
-		return true
-	}
-
-	switch signal.StringValue() {
-	case SignalLogs.StringValue():
-		return ctx == FieldContextLog || ctx == FieldContextBody
-	case SignalTraces.StringValue():
-		return ctx == FieldContextSpan || ctx == FieldContextEvent || ctx == FieldContextTrace
-	case SignalMetrics.StringValue():
-		return ctx == FieldContextMetric
-	}
-	return true
-}

pkg/valuer/string.go

@@ -77,10 +77,3 @@ func (enum *String) UnmarshalText(text []byte) error {
 func (enum String) MarshalText() (text []byte, err error) {
 	return []byte(enum.StringValue()), nil
 }
-
-// Implement Gin's BindUnmarshaler interface
-// See https://github.com/SigNoz/signoz/pull/10219 description for additional details
-func (enum *String) UnmarshalParam(param string) error {
-	*enum = NewString(param)
-	return nil
-}

tests/integration/src/cloudintegrations/02_generate_connection_url.py

@@ -0,0 +1,206 @@
+from http import HTTPStatus
+from typing import Callable
+
+import requests
+from sqlalchemy import text
+from wiremock.client import (
+    HttpMethods,
+    Mapping,
+    MappingRequest,
+    MappingResponse,
+    WireMockMatchers,
+)
+
+from fixtures import types
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD, add_license
+from fixtures.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+def cleanup_cloud_accounts(postgres: types.TestContainerSQL) -> None:
+    try:
+        with postgres.conn.connect() as conn:
+            conn.execute(text("TRUNCATE TABLE cloud_integration CASCADE"))
+            conn.commit()
+            logger.info("Cleaned up cloud_integration table")
+    except Exception as e:
+        logger.info(f"Cleanup skipped: {str(e)[:100]}")
+
+
+def test_generate_connection_url(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test to generate connection URL for AWS CloudFormation stack deployment."""
+    # Clean up any corrupted data from previous test runs
+    cleanup_cloud_accounts(postgres)
+
+    # Get authentication token for admin user
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    add_license(signoz, make_http_mocks, get_token)
+
+    cloud_provider = "aws"
+
+    # Mock the deployment info query (for license validation)
+    make_http_mocks(
+        signoz.zeus,
+        [
+            Mapping(
+                request=MappingRequest(
+                    method=HttpMethods.GET,
+                    url="/v2/deployments/me",
+                    headers={
+                        "X-Signoz-Cloud-Api-Key": {
+                            WireMockMatchers.EQUAL_TO: "secret-key"
+                        }
+                    },
+                ),
+                response=MappingResponse(
+                    status=200,
+                    json_body={
+                        "status": "success",
+                        "data": {
+                            "name": "test-deployment",
+                            "cluster": {"region": {"dns": "test.signoz.cloud"}},
+                        },
+                    },
+                ),
+                persistent=False,
+            )
+        ],
+    )
+
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/accounts/generate-connection-url"
+
+    # Prepare request payload
+    request_payload = {
+        "account_config": {"regions": ["us-east-1", "us-west-2"]},
+        "agent_config": {
+            "region": "us-east-1",
+            "ingestion_url": "https://ingest.test.signoz.cloud",
+            "ingestion_key": "test-ingestion-key-123456",
+            "signoz_api_url": "https://test-deployment.test.signoz.cloud",
+            "signoz_api_key": "test-api-key-789",
+            "version": "v0.0.8",
+        },
+    }
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json=request_payload,
+        timeout=10,
+    )
+
+    # Assert successful response
+    assert (
+        response.status_code == HTTPStatus.OK
+    ), f"Expected 200, got {response.status_code}: {response.text}"
+
+    # Parse response JSON
+    response_data = response.json()
+
+    # Assert response structure contains expected data
+    assert "data" in response_data, "Response should contain 'data' field"
+
+    # Assert required fields in the response data
+    expected_fields = ["account_id", "connection_url"]
+
+    for field in expected_fields:
+        assert (
+            field in response_data["data"]
+        ), f"Response data should contain '{field}' field"
+
+    data = response_data["data"]
+
+    # Assert account_id is a valid UUID format
+    assert (
+        len(data["account_id"]) > 0
+    ), "account_id should be a non-empty string (UUID)"
+
+    # Assert connection_url contains expected CloudFormation parameters
+    connection_url = data["connection_url"]
+
+    # Verify it's an AWS CloudFormation URL
+    assert (
+        "console.aws.amazon.com/cloudformation" in connection_url
+    ), "connection_url should be an AWS CloudFormation URL"
+
+    # Verify region is included
+    assert (
+        "region=us-east-1" in connection_url
+    ), "connection_url should contain the specified region"
+
+    # Verify required parameters are in the URL
+    required_params = [
+        "param_SigNozIntegrationAgentVersion=v0.0.8",
+        "param_SigNozApiUrl=https%3A%2F%2Ftest-deployment.test.signoz.cloud",
+        "param_SigNozApiKey=test-api-key-789",
+        "param_SigNozAccountId=",  # Will be a UUID
+        "param_IngestionUrl=https%3A%2F%2Fingest.test.signoz.cloud",
+        "param_IngestionKey=test-ingestion-key-123456",
+        "stackName=signoz-integration",
+        "templateURL=https%3A%2F%2Fsignoz-integrations.s3.us-east-1.amazonaws.com%2Faws-quickcreate-template-v0.0.8.json",
+    ]
+
+    for param in required_params:
+        assert (
+            param in connection_url
+        ), f"connection_url should contain parameter: {param}"
+
+    logger.info("Connection URL generated successfully")
+    logger.info(f"Account ID: {data['account_id']}")
+    logger.info(f"Connection URL length: {len(connection_url)} characters")
+
+def test_generate_connection_url_unsupported_provider(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+) -> None:
+    """Test that unsupported cloud providers return an error."""
+    # Get authentication token for admin user
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    add_license(signoz, make_http_mocks, get_token)
+
+    # Try with GCP (unsupported)
+    cloud_provider = "gcp"
+
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/accounts/generate-connection-url"
+
+    request_payload = {
+        "account_config": {"regions": ["us-central1"]},
+        "agent_config": {
+            "region": "us-central1",
+            "ingestion_url": "https://ingest.test.signoz.cloud",
+            "ingestion_key": "test-ingestion-key-123456",
+            "signoz_api_url": "https://test-deployment.test.signoz.cloud",
+            "signoz_api_key": "test-api-key-789",
+        },
+    }
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json=request_payload,
+        timeout=10,
+    )
+
+    # Should return Bad Request for unsupported provider
+    assert (
+        response.status_code == HTTPStatus.BAD_REQUEST
+    ), f"Expected 400 for unsupported provider, got {response.status_code}"
+
+    response_data = response.json()
+    assert "error" in response_data, "Response should contain 'error' field"
+    assert (
+        "unsupported cloud provider" in response_data["error"].lower()
+    ), "Error message should indicate unsupported provider"
+
+    logger.info("Unsupported provider correctly rejected with 400 Bad Request")

tests/integration/src/cloudintegrations/03_accounts.py

@@ -0,0 +1,590 @@
+from http import HTTPStatus
+from typing import Callable
+import uuid
+
+import pytest
+import requests
+from sqlalchemy import text
+from wiremock.client import (
+    HttpMethods,
+    Mapping,
+    MappingRequest,
+    MappingResponse,
+    WireMockMatchers,
+)
+
+from fixtures import types
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD, add_license
+from fixtures.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+def cleanup_cloud_accounts(postgres: types.TestContainerSQL) -> None:
+    try:
+        with postgres.conn.connect() as conn:
+            # Try to delete all records instead of truncate in case table exists
+            conn.execute(text("DELETE FROM cloud_integration"))
+            conn.commit()
+            logger.info("Cleaned up cloud_integration table")
+    except Exception as e:
+        # Table might not exist, which is fine
+        logger.info(f"Cleanup skipped or partial: {str(e)[:100]}")
+
+
+def generate_unique_cloud_account_id() -> str:
+    """Generate a unique cloud account ID for testing."""
+    # Use last 12 digits of UUID to simulate AWS account ID format
+    return str(uuid.uuid4().int)[:12]
+
+
+def simulate_agent_checkin(
+    signoz: types.SigNoz,
+    admin_token: str,
+    cloud_provider: str,
+    account_id: str,
+    cloud_account_id: str,
+) -> dict:
+    """Simulate an agent check-in to mark the account as connected.
+
+    Returns:
+        dict with the response from check-in
+    """
+    endpoint = (
+        f"/api/v1/cloud-integrations/{cloud_provider}/agent-check-in"
+    )
+
+    checkin_payload = {
+        "account_id": account_id,
+        "cloud_account_id": cloud_account_id,
+        "data": {},
+    }
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json=checkin_payload,
+        timeout=10,
+    )
+
+    if response.status_code != HTTPStatus.OK:
+        logger.error(f"Agent check-in failed: {response.status_code}, response: {response.text}")
+
+    assert (
+        response.status_code == HTTPStatus.OK
+    ), f"Agent check-in failed: {response.status_code}"
+
+    logger.info(f"Agent check-in completed for account: {account_id}")
+
+    response_data = response.json()
+    return response_data.get("data", response_data)
+
+
+def create_test_account(
+    signoz: types.SigNoz,
+    admin_token: str,
+    cloud_provider: str = "aws",
+) -> dict:
+    """Create a test account via generate-connection-url.
+
+    Returns the data as-is from the API response. Caller is responsible for
+    doing agent check-in if needed to mark the account as connected.
+
+    Returns:
+        dict with account_id and connection_url from the API
+    """
+    endpoint = (
+        f"/api/v1/cloud-integrations/{cloud_provider}/accounts/generate-connection-url"
+    )
+
+    request_payload = {
+        "account_config": {"regions": ["us-east-1"]},
+        "agent_config": {
+            "region": "us-east-1",
+            "ingestion_url": "https://ingest.test.signoz.cloud",
+            "ingestion_key": "test-ingestion-key-123456",
+            "signoz_api_url": "https://test-deployment.test.signoz.cloud",
+            "signoz_api_key": "test-api-key-789",
+            "version": "v0.0.8",
+        },
+    }
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json=request_payload,
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.OK
+    ), f"Failed to create test account: {response.status_code}"
+
+    response_data = response.json()
+    # API returns data wrapped in {'status': 'success', 'data': {...}}
+    data = response_data.get("data", response_data)
+
+    return data
+
+
+def test_list_connected_accounts_empty(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test listing connected accounts when there are none."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    cloud_provider = "aws"
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/accounts"
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.OK
+    ), f"Expected 200, got {response.status_code}"
+
+    response_data = response.json()
+    # API returns data wrapped in {'status': 'success', 'data': {...}}
+    data = response_data.get("data", response_data)
+    assert "accounts" in data, "Response should contain 'accounts' field"
+    assert isinstance(data["accounts"], list), "Accounts should be a list"
+
+    # Note: If table doesn't exist yet, cleanup won't work and there might be leftover data
+    # This is acceptable for integration tests with --reuse flag
+    initial_count = len(data["accounts"])
+    logger.info(f"Accounts list returned successfully with {initial_count} existing account(s)")
+
+
+def test_list_connected_accounts_with_account(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test listing connected accounts after creating one."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    # Mock the deployment info query
+    make_http_mocks(
+        signoz.zeus,
+        [
+            Mapping(
+                request=MappingRequest(
+                    method=HttpMethods.GET,
+                    url="/v2/deployments/me",
+                    headers={
+                        "X-Signoz-Cloud-Api-Key": {
+                            WireMockMatchers.EQUAL_TO: "secret-key"
+                        }
+                    },
+                ),
+                response=MappingResponse(
+                    status=200,
+                    json_body={
+                        "status": "success",
+                        "data": {
+                            "name": "test-deployment",
+                            "cluster": {"region": {"dns": "test.signoz.cloud"}},
+                        },
+                    },
+                ),
+                persistent=False,
+            )
+        ],
+    )
+
+    # Create a test account
+    cloud_provider = "aws"
+    account_data = create_test_account(signoz, admin_token, cloud_provider)
+    account_id = account_data["account_id"]
+
+    # Simulate agent check-in to mark as connected
+    cloud_account_id = generate_unique_cloud_account_id()
+    simulate_agent_checkin(signoz, admin_token, cloud_provider, account_id, cloud_account_id)
+
+    # List accounts
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/accounts"
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.OK
+    ), f"Expected 200, got {response.status_code}"
+
+    response_data = response.json()
+    data = response_data.get("data", response_data)
+    assert "accounts" in data, "Response should contain 'accounts' field"
+    assert isinstance(data["accounts"], list), "Accounts should be a list"
+
+    # Find our account in the list (there may be leftover accounts from previous test runs)
+    account = next((a for a in data["accounts"] if a["id"] == account_id), None)
+    assert account is not None, f"Account {account_id} should be found in list"
+    assert account["id"] == account_id, "Account ID should match"
+    assert "config" in account, "Account should have config field"
+    assert "status" in account, "Account should have status field"
+
+    logger.info(f"Found account in list: {account_id}")
+
+
+def test_get_account_status(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test getting the status of a specific account."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    # Mock the deployment info query
+    make_http_mocks(
+        signoz.zeus,
+        [
+            Mapping(
+                request=MappingRequest(
+                    method=HttpMethods.GET,
+                    url="/v2/deployments/me",
+                    headers={
+                        "X-Signoz-Cloud-Api-Key": {
+                            WireMockMatchers.EQUAL_TO: "secret-key"
+                        }
+                    },
+                ),
+                response=MappingResponse(
+                    status=200,
+                    json_body={
+                        "status": "success",
+                        "data": {
+                            "name": "test-deployment",
+                            "cluster": {"region": {"dns": "test.signoz.cloud"}},
+                        },
+                    },
+                ),
+                persistent=False,
+            )
+        ],
+    )
+
+    # Create a test account (no check-in needed for status check)
+    cloud_provider = "aws"
+    account_data = create_test_account(signoz, admin_token, cloud_provider)
+    account_id = account_data["account_id"]
+
+    # Get account status
+    endpoint = (
+        f"/api/v1/cloud-integrations/{cloud_provider}/accounts/{account_id}/status"
+    )
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.OK
+    ), f"Expected 200, got {response.status_code}"
+
+    response_data = response.json()
+    data = response_data.get("data", response_data)
+    assert "id" in data, "Response should contain 'id' field"
+    assert data["id"] == account_id, "Account ID should match"
+    assert "status" in data, "Response should contain 'status' field"
+    assert "integration" in data["status"], "Status should contain 'integration' field"
+
+    logger.info(f"Retrieved status for account: {account_id}")
+
+
+def test_get_account_status_not_found(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test getting status for a non-existent account."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    cloud_provider = "aws"
+    fake_account_id = "00000000-0000-0000-0000-000000000000"
+
+    endpoint = (
+        f"/api/v1/cloud-integrations/{cloud_provider}/accounts/{fake_account_id}/status"
+    )
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.NOT_FOUND
+    ), f"Expected 404, got {response.status_code}"
+
+    logger.info("Non-existent account correctly returned 404")
+
+
+def test_update_account_config(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test updating account configuration."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    # Mock the deployment info query
+    make_http_mocks(
+        signoz.zeus,
+        [
+            Mapping(
+                request=MappingRequest(
+                    method=HttpMethods.GET,
+                    url="/v2/deployments/me",
+                    headers={
+                        "X-Signoz-Cloud-Api-Key": {
+                            WireMockMatchers.EQUAL_TO: "secret-key"
+                        }
+                    },
+                ),
+                response=MappingResponse(
+                    status=200,
+                    json_body={
+                        "status": "success",
+                        "data": {
+                            "name": "test-deployment",
+                            "cluster": {"region": {"dns": "test.signoz.cloud"}},
+                        },
+                    },
+                ),
+                persistent=False,
+            )
+        ],
+    )
+
+    # Create a test account
+    cloud_provider = "aws"
+    account_data = create_test_account(signoz, admin_token, cloud_provider)
+    account_id = account_data["account_id"]
+
+    # Simulate agent check-in to mark as connected
+    cloud_account_id = generate_unique_cloud_account_id()
+    simulate_agent_checkin(signoz, admin_token, cloud_provider, account_id, cloud_account_id)
+
+    # Update account configuration
+    endpoint = (
+        f"/api/v1/cloud-integrations/{cloud_provider}/accounts/{account_id}/config"
+    )
+
+    updated_config = {
+        "config": {"regions": ["us-east-1", "us-west-2", "eu-west-1"]}
+    }
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json=updated_config,
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.OK
+    ), f"Expected 200, got {response.status_code}"
+
+    response_data = response.json()
+    data = response_data.get("data", response_data)
+    assert "id" in data, "Response should contain 'id' field"
+    assert data["id"] == account_id, "Account ID should match"
+
+    # Verify the update by listing accounts
+    list_endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/accounts"
+    list_response = requests.get(
+        signoz.self.host_configs["8080"].get(list_endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+
+    list_response_data = list_response.json()
+    list_data = list_response_data.get("data", list_response_data)
+    account = next((a for a in list_data["accounts"] if a["id"] == account_id), None)
+    assert account is not None, "Account should be found in list"
+    assert "config" in account, "Account should have config"
+    assert "regions" in account["config"], "Config should have regions"
+    assert len(account["config"]["regions"]) == 3, "Should have 3 regions"
+    assert set(account["config"]["regions"]) == {
+        "us-east-1",
+        "us-west-2",
+        "eu-west-1",
+    }, "Regions should match updated config"
+
+    logger.info(f"Updated account configuration: {account_id}")
+
+
+def test_disconnect_account(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test disconnecting an account."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    # Mock the deployment info query
+    make_http_mocks(
+        signoz.zeus,
+        [
+            Mapping(
+                request=MappingRequest(
+                    method=HttpMethods.GET,
+                    url="/v2/deployments/me",
+                    headers={
+                        "X-Signoz-Cloud-Api-Key": {
+                            WireMockMatchers.EQUAL_TO: "secret-key"
+                        }
+                    },
+                ),
+                response=MappingResponse(
+                    status=200,
+                    json_body={
+                        "status": "success",
+                        "data": {
+                            "name": "test-deployment",
+                            "cluster": {"region": {"dns": "test.signoz.cloud"}},
+                        },
+                    },
+                ),
+                persistent=False,
+            )
+        ],
+    )
+
+    # Create a test account
+    cloud_provider = "aws"
+    account_data = create_test_account(signoz, admin_token, cloud_provider)
+    account_id = account_data["account_id"]
+
+    # Simulate agent check-in to mark as connected
+    cloud_account_id = generate_unique_cloud_account_id()
+    simulate_agent_checkin(signoz, admin_token, cloud_provider, account_id, cloud_account_id)
+
+    # Disconnect the account
+    endpoint = (
+        f"/api/v1/cloud-integrations/{cloud_provider}/accounts/{account_id}/disconnect"
+    )
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.OK
+    ), f"Expected 200, got {response.status_code}"
+
+    # Verify account is no longer in the connected list
+    list_endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/accounts"
+    list_response = requests.get(
+        signoz.self.host_configs["8080"].get(list_endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    list_response_data = list_response.json()
+    list_data = list_response_data.get("data", list_response_data)
+    assert len(list_data["accounts"]) == 0, "Should have no connected accounts"
+
+    logger.info(f"Disconnected account: {account_id}")
+
+
+def test_disconnect_account_not_found(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test disconnecting a non-existent account."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    cloud_provider = "aws"
+    fake_account_id = "00000000-0000-0000-0000-000000000000"
+
+    endpoint = (
+        f"/api/v1/cloud-integrations/{cloud_provider}/accounts/{fake_account_id}/disconnect"
+    )
+
+    response = requests.delete(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.NOT_FOUND
+    ), f"Expected 404, got {response.status_code}"
+
+    logger.info("Disconnect non-existent account correctly returned 404")
+
+
+def test_list_accounts_unsupported_provider(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test listing accounts for an unsupported cloud provider."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    cloud_provider = "gcp"  # Unsupported provider
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/accounts"
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.BAD_REQUEST
+    ), f"Expected 400, got {response.status_code}"
+
+    logger.info("Unsupported provider correctly rejected with 400 Bad Request")

tests/integration/src/cloudintegrations/04_services.py

@@ -0,0 +1,787 @@
+from http import HTTPStatus
+from typing import Callable
+import uuid
+
+import requests
+from sqlalchemy import text
+from wiremock.client import (
+    HttpMethods,
+    Mapping,
+    MappingRequest,
+    MappingResponse,
+    WireMockMatchers,
+)
+
+from fixtures import types
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD, add_license
+from fixtures.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+def cleanup_cloud_accounts(postgres: types.TestContainerSQL) -> None:
+    """Clean up cloud_integration table to avoid corrupted data issues."""
+    try:
+        with postgres.conn.connect() as conn:
+            # Try to delete all records instead of truncate in case table exists
+            conn.execute(text("DELETE FROM cloud_integration"))
+            conn.commit()
+            logger.info("Cleaned up cloud_integration table")
+    except Exception as e:
+        # Table might not exist, which is fine
+        logger.info(f"Cleanup skipped or partial: {str(e)[:100]}")
+
+
+def generate_unique_cloud_account_id() -> str:
+    """Generate a unique cloud account ID for testing."""
+    # Use last 12 digits of UUID to simulate AWS account ID format
+    return str(uuid.uuid4().int)[:12]
+
+
+def simulate_agent_checkin(
+    signoz: types.SigNoz,
+    admin_token: str,
+    cloud_provider: str,
+    account_id: str,
+    cloud_account_id: str,
+) -> dict:
+    """Simulate an agent check-in to mark the account as connected.
+
+    Returns:
+        dict with the response from check-in
+    """
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/agent-check-in"
+
+    checkin_payload = {
+        "account_id": account_id,
+        "cloud_account_id": cloud_account_id,
+        "data": {},
+    }
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json=checkin_payload,
+        timeout=10,
+    )
+
+    if response.status_code != HTTPStatus.OK:
+        logger.error(
+            f"Agent check-in failed: {response.status_code}, response: {response.text}"
+        )
+
+    assert (
+        response.status_code == HTTPStatus.OK
+    ), f"Agent check-in failed: {response.status_code}"
+
+    logger.info(f"Agent check-in completed for account: {account_id}")
+
+    response_data = response.json()
+    return response_data.get("data", response_data)
+
+
+def create_test_account(
+    signoz: types.SigNoz,
+    admin_token: str,
+    cloud_provider: str = "aws",
+) -> dict:
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/accounts/generate-connection-url"
+
+    request_payload = {
+        "account_config": {"regions": ["us-east-1"]},
+        "agent_config": {
+            "region": "us-east-1",
+            "ingestion_url": "https://ingest.test.signoz.cloud",
+            "ingestion_key": "test-ingestion-key-123456",
+            "signoz_api_url": "https://test-deployment.test.signoz.cloud",
+            "signoz_api_key": "test-api-key-789",
+            "version": "v0.0.8",
+        },
+    }
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json=request_payload,
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.OK
+    ), f"Failed to create test account: {response.status_code}"
+
+    response_data = response.json()
+    # API returns data wrapped in {'status': 'success', 'data': {...}}
+    data = response_data.get("data", response_data)
+
+    return data
+
+
+def test_list_services_without_account(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test listing available services without specifying an account."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    cloud_provider = "aws"
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services"
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.OK
+    ), f"Expected 200, got {response.status_code}"
+
+    response_data = response.json()
+    data = response_data.get("data", response_data)
+    assert "services" in data, "Response should contain 'services' field"
+    assert isinstance(data["services"], list), "Services should be a list"
+    assert len(data["services"]) > 0, "Should have at least one service available"
+
+    # Verify service structure
+    service = data["services"][0]
+    assert "id" in service, "Service should have 'id' field"
+    assert "title" in service, "Service should have 'title' field"
+    assert "icon" in service, "Service should have 'icon' field"
+
+
+def test_list_services_with_account(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test listing services for a specific connected account."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    # Mock the deployment info query
+    make_http_mocks(
+        signoz.zeus,
+        [
+            Mapping(
+                request=MappingRequest(
+                    method=HttpMethods.GET,
+                    url="/v2/deployments/me",
+                    headers={
+                        "X-Signoz-Cloud-Api-Key": {
+                            WireMockMatchers.EQUAL_TO: "secret-key"
+                        }
+                    },
+                ),
+                response=MappingResponse(
+                    status=200,
+                    json_body={
+                        "status": "success",
+                        "data": {
+                            "name": "test-deployment",
+                            "cluster": {"region": {"dns": "test.signoz.cloud"}},
+                        },
+                    },
+                ),
+                persistent=False,
+            )
+        ],
+    )
+
+    # Create a test account and do check-in
+    cloud_provider = "aws"
+    account_data = create_test_account(signoz, admin_token, cloud_provider)
+    account_id = account_data["account_id"]
+
+    cloud_account_id = generate_unique_cloud_account_id()
+    simulate_agent_checkin(
+        signoz, admin_token, cloud_provider, account_id, cloud_account_id
+    )
+
+    # List services for the account
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services?cloud_account_id={cloud_account_id}"
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.OK
+    ), f"Expected 200, got {response.status_code}"
+
+    response_data = response.json()
+    data = response_data.get("data", response_data)
+    assert "services" in data, "Response should contain 'services' field"
+    assert isinstance(data["services"], list), "Services should be a list"
+    assert len(data["services"]) > 0, "Should have at least one service available"
+
+    # Services should include config field (may be null if not configured)
+    service = data["services"][0]
+    assert "id" in service, "Service should have 'id' field"
+    assert "title" in service, "Service should have 'title' field"
+    assert "icon" in service, "Service should have 'icon' field"
+
+    logger.info(
+        f"Listed {len(data['services'])} services for account {cloud_account_id}"
+    )
+
+
+def test_get_service_details_without_account(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test getting service details without specifying an account."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    cloud_provider = "aws"
+    # First get the list of services to get a valid service ID
+    list_endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services"
+    list_response = requests.get(
+        signoz.self.host_configs["8080"].get(list_endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    list_data = list_response.json().get("data", list_response.json())
+    assert len(list_data["services"]) > 0, "Should have at least one service"
+    service_id = list_data["services"][0]["id"]
+
+    # Get service details
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services/{service_id}"
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.OK
+    ), f"Expected 200, got {response.status_code}"
+
+    response_data = response.json()
+    data = response_data.get("data", response_data)
+
+    # Verify service details structure
+    assert "id" in data, "Service details should have 'id' field"
+    assert data["id"] == service_id, "Service ID should match requested ID"
+    assert "title" in data, "Service details should have 'name' field"
+    assert "overview" in data, "Service details should have 'overview' field"
+    # assert assets to had list of dashboards
+    assert "assets" in data, "Service details should have 'assets' field"
+    assert isinstance(data["assets"], dict), "Assets should be a dictionary"
+
+    logger.info(f"Retrieved details for service: {service_id}")
+
+
+def test_get_service_details_with_account(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test getting service details for a specific connected account."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    # Mock the deployment info query
+    make_http_mocks(
+        signoz.zeus,
+        [
+            Mapping(
+                request=MappingRequest(
+                    method=HttpMethods.GET,
+                    url="/v2/deployments/me",
+                    headers={
+                        "X-Signoz-Cloud-Api-Key": {
+                            WireMockMatchers.EQUAL_TO: "secret-key"
+                        }
+                    },
+                ),
+                response=MappingResponse(
+                    status=200,
+                    json_body={
+                        "status": "success",
+                        "data": {
+                            "name": "test-deployment",
+                            "cluster": {"region": {"dns": "test.signoz.cloud"}},
+                        },
+                    },
+                ),
+                persistent=False,
+            )
+        ],
+    )
+
+    # Create a test account and do check-in
+    cloud_provider = "aws"
+    account_data = create_test_account(signoz, admin_token, cloud_provider)
+    account_id = account_data["account_id"]
+
+    cloud_account_id = generate_unique_cloud_account_id()
+    simulate_agent_checkin(
+        signoz, admin_token, cloud_provider, account_id, cloud_account_id
+    )
+
+    # Get list of services first
+    list_endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services"
+    list_response = requests.get(
+        signoz.self.host_configs["8080"].get(list_endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    list_data = list_response.json().get("data", list_response.json())
+    assert len(list_data["services"]) > 0, "Should have at least one service"
+    service_id = list_data["services"][0]["id"]
+
+    # Get service details with account
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services/{service_id}?cloud_account_id={cloud_account_id}"
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.OK
+    ), f"Expected 200, got {response.status_code}"
+
+    response_data = response.json()
+    data = response_data.get("data", response_data)
+
+    # Verify service details structure
+    assert "id" in data, "Service details should have 'id' field"
+    assert data["id"] == service_id, "Service ID should match requested ID"
+    assert "title" in data, "Service details should have 'title' field"
+    assert "overview" in data, "Service details should have 'overview' field"
+    assert "assets" in data, "Service details should have 'assets' field"
+    assert "config" in data, "Service details should have 'config' field"
+    assert "status" in data, "Config should have 'status' field"
+
+    logger.info(
+        f"Retrieved details for service {service_id} with account {cloud_account_id}"
+    )
+
+
+def test_get_service_details_invalid_service(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test getting details for a non-existent service."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    cloud_provider = "aws"
+    fake_service_id = "non-existent-service"
+
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services/{fake_service_id}"
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.NOT_FOUND
+    ), f"Expected 404, got {response.status_code}"
+
+    logger.info("Non-existent service correctly returned 404")
+
+
+def test_list_services_unsupported_provider(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test listing services for an unsupported cloud provider."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    cloud_provider = "gcp"  # Unsupported provider
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services"
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.BAD_REQUEST
+    ), f"Expected 400, got {response.status_code}"
+
+    logger.info(
+        "Unsupported provider correctly rejected with 400 Bad Request for services"
+    )
+
+
+def test_update_service_config(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test updating service configuration for a connected account."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    # Mock the deployment info query
+    make_http_mocks(
+        signoz.zeus,
+        [
+            Mapping(
+                request=MappingRequest(
+                    method=HttpMethods.GET,
+                    url="/v2/deployments/me",
+                    headers={
+                        "X-Signoz-Cloud-Api-Key": {
+                            WireMockMatchers.EQUAL_TO: "secret-key"
+                        }
+                    },
+                ),
+                response=MappingResponse(
+                    status=200,
+                    json_body={
+                        "status": "success",
+                        "data": {
+                            "name": "test-deployment",
+                            "cluster": {"region": {"dns": "test.signoz.cloud"}},
+                        },
+                    },
+                ),
+                persistent=False,
+            )
+        ],
+    )
+
+    # Create a test account and do check-in
+    cloud_provider = "aws"
+    account_data = create_test_account(signoz, admin_token, cloud_provider)
+    account_id = account_data["account_id"]
+
+    cloud_account_id = generate_unique_cloud_account_id()
+    simulate_agent_checkin(
+        signoz, admin_token, cloud_provider, account_id, cloud_account_id
+    )
+
+    # Get list of services to pick a valid service ID
+    list_endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services"
+    list_response = requests.get(
+        signoz.self.host_configs["8080"].get(list_endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    list_data = list_response.json().get("data", list_response.json())
+    assert len(list_data["services"]) > 0, "Should have at least one service"
+    service_id = list_data["services"][0]["id"]
+
+    # Update service configuration
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services/{service_id}/config"
+
+    config_payload = {
+        "cloud_account_id": cloud_account_id,
+        "config": {
+            "metrics": {"enabled": True},
+            "logs": {"enabled": True},
+        },
+    }
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json=config_payload,
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.OK
+    ), f"Expected 200, got {response.status_code}"
+
+    response_data = response.json()
+    data = response_data.get("data", response_data)
+
+    # Verify response structure
+    assert "id" in data, "Response should contain 'id' field"
+    assert data["id"] == service_id, "Service ID should match"
+    assert "config" in data, "Response should contain 'config' field"
+    assert "metrics" in data["config"], "Config should contain 'metrics' field"
+    assert "logs" in data["config"], "Config should contain 'logs' field"
+
+    logger.info(f"Updated service config for {service_id} on account {cloud_account_id}")
+
+
+def test_update_service_config_without_account(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test updating service config without a connected account should fail."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    cloud_provider = "aws"
+
+    # Get a valid service ID
+    list_endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services"
+    list_response = requests.get(
+        signoz.self.host_configs["8080"].get(list_endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    list_data = list_response.json().get("data", list_response.json())
+    service_id = list_data["services"][0]["id"]
+
+    # Try to update config with non-existent account
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services/{service_id}/config"
+
+    fake_cloud_account_id = generate_unique_cloud_account_id()
+    config_payload = {
+        "cloud_account_id": fake_cloud_account_id,
+        "config": {
+            "metrics": {"enabled": True},
+        },
+    }
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json=config_payload,
+        timeout=10,
+    )
+
+
+    # todo: improve the handler logic to return 500
+    assert (
+        response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
+    ), f"Expected 500 for non-existent account, got {response.status_code}"
+
+    logger.info("Update service config correctly rejected for non-existent account")
+
+
+def test_update_service_config_invalid_service(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test updating config for a non-existent service should fail."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    # Mock the deployment info query
+    make_http_mocks(
+        signoz.zeus,
+        [
+            Mapping(
+                request=MappingRequest(
+                    method=HttpMethods.GET,
+                    url="/v2/deployments/me",
+                    headers={
+                        "X-Signoz-Cloud-Api-Key": {
+                            WireMockMatchers.EQUAL_TO: "secret-key"
+                        }
+                    },
+                ),
+                response=MappingResponse(
+                    status=200,
+                    json_body={
+                        "status": "success",
+                        "data": {
+                            "name": "test-deployment",
+                            "cluster": {"region": {"dns": "test.signoz.cloud"}},
+                        },
+                    },
+                ),
+                persistent=False,
+            )
+        ],
+    )
+
+    # Create a test account and do check-in
+    cloud_provider = "aws"
+    account_data = create_test_account(signoz, admin_token, cloud_provider)
+    account_id = account_data["account_id"]
+
+    cloud_account_id = generate_unique_cloud_account_id()
+    simulate_agent_checkin(
+        signoz, admin_token, cloud_provider, account_id, cloud_account_id
+    )
+
+    # Try to update config for invalid service
+    fake_service_id = "non-existent-service"
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services/{fake_service_id}/config"
+
+    config_payload = {
+        "cloud_account_id": cloud_account_id,
+        "config": {
+            "metrics": {"enabled": True},
+        },
+    }
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json=config_payload,
+        timeout=10,
+    )
+
+    assert (
+        response.status_code == HTTPStatus.NOT_FOUND
+    ), f"Expected 404 for invalid service, got {response.status_code}"
+
+    logger.info("Update service config correctly rejected for invalid service")
+
+
+def test_update_service_config_disable_service(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
+    get_token: Callable[[str, str], str],
+    postgres: types.TestContainerSQL,
+) -> None:
+    """Test disabling a service by updating config with enabled=false."""
+    cleanup_cloud_accounts(postgres)
+
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    add_license(signoz, make_http_mocks, get_token)
+
+    # Mock the deployment info query
+    make_http_mocks(
+        signoz.zeus,
+        [
+            Mapping(
+                request=MappingRequest(
+                    method=HttpMethods.GET,
+                    url="/v2/deployments/me",
+                    headers={
+                        "X-Signoz-Cloud-Api-Key": {
+                            WireMockMatchers.EQUAL_TO: "secret-key"
+                        }
+                    },
+                ),
+                response=MappingResponse(
+                    status=200,
+                    json_body={
+                        "status": "success",
+                        "data": {
+                            "name": "test-deployment",
+                            "cluster": {"region": {"dns": "test.signoz.cloud"}},
+                        },
+                    },
+                ),
+                persistent=False,
+            )
+        ],
+    )
+
+    # Create a test account and do check-in
+    cloud_provider = "aws"
+    account_data = create_test_account(signoz, admin_token, cloud_provider)
+    account_id = account_data["account_id"]
+
+    cloud_account_id = generate_unique_cloud_account_id()
+    simulate_agent_checkin(
+        signoz, admin_token, cloud_provider, account_id, cloud_account_id
+    )
+
+    # Get a valid service
+    list_endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services"
+    list_response = requests.get(
+        signoz.self.host_configs["8080"].get(list_endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=10,
+    )
+
+    list_data = list_response.json().get("data", list_response.json())
+    service_id = list_data["services"][0]["id"]
+
+    # First enable the service
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services/{service_id}/config"
+
+    enable_payload = {
+        "cloud_account_id": cloud_account_id,
+        "config": {
+            "metrics": {"enabled": True},
+        },
+    }
+
+    enable_response = requests.post(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json=enable_payload,
+        timeout=10,
+    )
+
+    assert enable_response.status_code == HTTPStatus.OK, "Failed to enable service"
+
+    # Now disable the service
+    disable_payload = {
+        "cloud_account_id": cloud_account_id,
+        "config": {
+            "metrics": {"enabled": False},
+            "logs": {"enabled": False},
+        },
+    }
+
+    disable_response = requests.post(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json=disable_payload,
+        timeout=10,
+    )
+
+    assert (
+        disable_response.status_code == HTTPStatus.OK
+    ), f"Expected 200, got {disable_response.status_code}"
+
+    response_data = disable_response.json()
+    data = response_data.get("data", response_data)
+
+    # Verify service is disabled
+    assert data["config"]["metrics"]["enabled"] == False, "Metrics should be disabled"
+    assert data["config"]["logs"]["enabled"] == False, "Logs should be disabled"
+
+    logger.info(f"Successfully disabled service {service_id}")
+