test: adding tests for covering GCP integrations across APIs

docs/contributing/go/handler.md

@@ -349,7 +349,7 @@ func (Step) JSONSchema() (jsonschema.Schema, error) {
 
 ### `oneOf` with a discriminator
 
-For a sum type whose variants are keyed by a property (e.g. `kind`), expose the variants via `JSONSchemaOneOf()` and add a discriminator. Without it, code generators intersect the variants (`A & B & C`) instead of producing a clean discriminated union (`A | B | C`). How to model the sum type itself is covered in [types.md](types.md#sum-types-the-kindspec-envelope) — this section is only about its schema.
+For a sum type whose variants are keyed by a property (e.g. `kind`), expose the variants via `JSONSchemaOneOf()` and add a discriminator. Without it, code generators intersect the variants (`A & B & C`) instead of producing a clean discriminated union (`A | B | C`).
 
 The parent keeps its `JSONSchemaOneOf()` (the `oneOf` itself) and *additionally* tags it via `PrepareJSONSchema` with the `x-signoz-discriminator` extension; `signoz.attachDiscriminators` then promotes that marker to a real OpenAPI 3 `discriminator` (and strips the duplicate parent properties) after reflection.
 

docs/contributing/go/types.md

@@ -99,69 +99,6 @@ Each flavor exists for a concrete reason:
 
 The core `AuthDomain` holds the two live halves — `storableAuthDomain` and `authDomainConfig` — and owns business methods such as `Update(config)`. Conversions use the `New<Output>From<Input>` form: `NewAuthDomainFromConfig`, `NewAuthDomainFromStorableAuthDomain`, `NewGettableAuthDomainFromAuthDomain`.
 
-## Sum types: the kind/spec envelope
-
-When a domain type is a *sum type* — exactly one of several variants, selected by a discriminator — model it as an envelope with a `kind` and a `spec`:
-
-```go
-type FooConfig struct {
-    Kind FooKind `json:"kind" required:"true"`
-    Spec any     `json:"spec" required:"true"`
-}
-```
-
-```json
-{ "kind": "bar", "spec": { "url": "...", "timeout": "30s" } }
-```
-
-`Kind` is a `valuer.String` enum implementing `Enum()`; `Spec` holds exactly one concrete variant type (`BarSpec`, `BazSpec`, …). `RuleThresholdData` and `EvaluationEnvelope` in `pkg/types/ruletypes/` are the canonical in-tree examples; the dashboard panel/query/variable plugins in `pkg/types/dashboardtypes/` are the same pattern behind generics. (`QueryEnvelope` in querybuildertypes uses `type` as the discriminator key for historical reasons; new envelopes use `kind`.)
-
-### The envelope goes at the point of variance, not the resource root
-
-Put the envelope on the field that actually varies. The resource root is almost never a sum type — a `Foo` has a `name` and an `enabled` flag regardless of which kind it is configured with; only its configuration varies, so the envelope is the `config` field:
-
-```json
-{ "name": "my-foo", "enabled": true, "config": { "kind": "bar", "spec": { "...": "..." } } }
-```
-
-Hoisting `kind`/`spec` to the root would turn the whole resource into a `oneOf`: every flavor (`PostableFoo`, `UpdatableFoo`, `GettableFoo`) then needs one variant schema per kind, each repeating the common fields; every new common field has to be added to all of them; and generated clients get unions of large objects instead of one small union that narrows on `config.kind`. A root-level `kind` also collides with the resource-model meaning of the word — root `kind` conventionally answers "what resource is this" (`Dashboard`), never "which flavor of config does it hold".
-
-The existing domains already follow this placement:
-
-- **Rules** — plain root; envelopes on the varying fields: `thresholds: {kind, spec}` and `evaluation: {kind, spec}`.
-- **Dashboards** — metadata at the root plus one typed `spec`; the unions sit deep inside, at each panel/query/variable plugin (`{kind, spec}` in `perses_plugin_wrappers.go`).
-- **Saved views** — root `{schemaVersion, spec}`, where `spec` is a *versioning* envelope holding one fixed type, not a union; the unions are inside it (`spec.queries: [{type, spec}]`). Same word, different job — a versioned body is not a discriminated union.
-
-### Why this tagging style
-
-Of the union encodings in common use, the envelope is the *adjacently tagged* one — tag and payload side by side. Variant payloads stay collision-free, and each kind maps to a named wrapper schema that carries the discriminator, which is exactly what OpenAPI generators need. The alternatives lose on those points: *internally tagged* (`{"kind": "bar", ...fields flattened}`) mixes common and variant fields, admits cross-variant key collisions, and forces every variant schema to redeclare the discriminator; *sibling optional fields* (`{"kind": "bar", "barConfig": {}, "bazConfig": {}}`) is the anti-pattern the first rule below exists to prevent.
-
-The rules that make the envelope work:
-
-- **Never model variants as sibling fields.** A struct with `Bar *BarSpec`, `Baz *BazSpec` next to a discriminator cannot be expressed as an OpenAPI discriminated union, forces nilability checks on every consumer, and silently admits contradictory payloads (kind=bar with a baz spec). The chosen variant *is* the payload.
-- **The envelope owns `UnmarshalJSON`.** Decode `kind` first, then switch on it to decode and validate the matching concrete type into `Spec`. Unknown kinds and missing specs are rejected at the boundary:
-
-    ```go
-    func (typ *FooConfig) UnmarshalJSON(data []byte) error {
-        var raw map[string]json.RawMessage
-        // ... unmarshal raw, decode raw["kind"] ...
-        switch kind {
-        case FooKindBar:
-            spec := BarSpec{}
-            if err := json.Unmarshal(raw["spec"], &spec); err != nil {
-                return err
-            }
-            typ.Spec = spec
-        // ... one case per kind, default rejects ...
-        }
-        typ.Kind = kind
-        return nil
-    }
-    ```
-- **Consumers type-assert on `Spec`** (`config.Spec.(BarSpec)`) after switching on `Kind`. If assertion sites multiply, add typed accessors on the envelope (see `EvaluationEnvelope.GetEvaluation()`).
-- **OpenAPI needs one unexported variant struct per kind** (`fooConfigBar{Kind; Spec BarSpec}`), exposed via `JSONSchemaOneOf()` and mapped via `PrepareJSONSchema` with the `x-signoz-discriminator` extension. The schema mechanics are covered in [handler.md](handler.md#oneof-with-a-discriminator).
-- **A legacy persisted shape gets a data migration or a `StorableX`.** When rows were written before the envelope existed, prefer an idempotent `sqlmigration` that rewrites them into the new shape, so the storable type simply nests the envelope. Only when the old shape must keep being written (external writers, rollback windows) keep it in a storable twin and convert at the type boundary.
-
 ## Conventions that tie the flavors together
 
 - **Conversions** use either a `New<Output>From<Input>` constructor — e.g. `NewChannelFromReceiver`, `NewGettableAuthDomainFromAuthDomain` — or a receiver-style `ToY()` method. Both forms coexist in the codebase; use whichever fits the call site.
@@ -202,8 +139,6 @@ Both are optional. Do not introduce them if `PostableX` already covers the case.
 
 - Every domain package defines the core type `X`. Only `X` is mandatory.
 - Add `PostableX` / `GettableX` / `UpdatableX` / `StorableX` one at a time, only when the shape actually diverges from `X`.
-- Model sum types as a `{kind, spec}` envelope with a validating `UnmarshalJSON` — never as sibling variant fields next to a discriminator.
-- The envelope goes on the field that varies, never at the resource root — common fields stay on the resource, outside the union.
 - Domain logic lives on `X`, not on the flavor types.
 - Conversions can be a `New<Output>From<Input>` constructor or a receiver-style `ToY()` method — pick whichever reads best at the call site.
 - Use a type alias when two shapes are truly identical.

frontend/src/components/LogDetail/LogHighlights/LogHighlights.module.scss

@@ -1,46 +0,0 @@
-.highlights {
-	display: grid;
-	grid-template-columns: repeat(4, minmax(0, 1fr));
-	gap: 12px 16px;
-	padding: 12px 0;
-
-	// Constrain each KeyValueLabel (the grid items) to its cell.
-	:global(.key-value-label) {
-		width: auto;
-		min-width: 0;
-		overflow: hidden;
-	}
-}
-
-.valueBadge {
-	--badge-font-size: 13px;
-	box-sizing: border-box;
-	max-width: 100%;
-	min-width: 0;
-}
-
-// Truncating text inside a badge
-.badgeText {
-	min-width: 0;
-	overflow: hidden;
-	text-overflow: ellipsis;
-	white-space: nowrap;
-}
-
-.serviceDot {
-	width: 6px;
-	height: 6px;
-	border-radius: 50%;
-	background: var(--accent-forest);
-	flex-shrink: 0;
-	margin-right: 4px;
-}
-
-.traceLink {
-	display: inline-block;
-	max-width: 100%;
-	overflow: hidden;
-	text-overflow: ellipsis;
-	white-space: nowrap;
-	color: var(--accent-primary);
-}

frontend/src/components/LogDetail/LogHighlights/LogHighlights.tsx

@@ -1,36 +0,0 @@
-import KeyValueLabel from 'periscope/components/KeyValueLabel';
-import { ILog } from 'types/api/logs/log';
-
-import { LOG_HIGHLIGHTS } from './config';
-import styles from './LogHighlights.module.scss';
-
-interface LogHighlightsProps {
-	log: ILog;
-}
-
-function LogHighlights({ log }: LogHighlightsProps): JSX.Element | null {
-	const fields = LOG_HIGHLIGHTS.map((field) => ({
-		key: field.key,
-		label: field.label,
-		value: field.render(log),
-	})).filter((field) => field.value != null);
-
-	if (fields.length === 0) {
-		return null;
-	}
-
-	return (
-		<div className={styles.highlights} data-testid="log-details-highlights">
-			{fields.map((field) => (
-				<KeyValueLabel
-					key={field.key}
-					badgeKey={field.label}
-					badgeValue={field.value}
-					direction="column"
-				/>
-			))}
-		</div>
-	);
-}
-
-export default LogHighlights;

frontend/src/components/LogDetail/LogHighlights/TraceIdField.tsx

@@ -1,23 +0,0 @@
-import { Link } from 'react-router-dom';
-
-import styles from './LogHighlights.module.scss';
-
-interface TraceIdFieldProps {
-	traceId: string;
-}
-
-function TraceIdField({ traceId }: TraceIdFieldProps): JSX.Element {
-	return (
-		<Link
-			to={{ pathname: `/trace/${traceId}` }}
-			target="_blank"
-			rel="noreferrer"
-			className={styles.traceLink}
-			title={traceId}
-		>
-			{traceId}
-		</Link>
-	);
-}
-
-export default TraceIdField;

frontend/src/components/LogDetail/LogHighlights/config.tsx

@@ -1,102 +0,0 @@
-import { ReactNode } from 'react';
-import { Badge, BadgeColor } from '@signozhq/ui/badge';
-import { LogType } from 'components/Logs/LogStateIndicator/LogStateIndicator';
-import { getLogIndicatorType } from 'components/Logs/LogStateIndicator/utils';
-import { ILog } from 'types/api/logs/log';
-
-import styles from './LogHighlights.module.scss';
-import TraceIdField from './TraceIdField';
-
-// Severity badge color mirrors the LogStateIndicator bar
-const SEVERITY_COLOR: Record<string, BadgeColor> = {
-	[LogType.TRACE]: 'forest',
-	[LogType.DEBUG]: 'aqua',
-	[LogType.INFO]: 'robin',
-	[LogType.WARN]: 'amber',
-	[LogType.ERROR]: 'cherry',
-	[LogType.FATAL]: 'sakura',
-};
-
-export interface LogHighlightConfig {
-	key: string;
-	label: string;
-	render: (log: ILog) => ReactNode | null;
-}
-
-// Resource/attribute lookup (keys like `service.name` live in resources_string,
-// occasionally attributes_string). Typed loosely as these are string maps.
-const getAttr = (log: ILog, key: string): string =>
-	(log.resources_string as unknown as Record<string, string>)?.[key] ||
-	(log.attributes_string as unknown as Record<string, string>)?.[key] ||
-	'';
-
-const valueBadge = (
-	value: string,
-	options?: { prefix?: ReactNode; color?: BadgeColor },
-): ReactNode => (
-	<Badge color={options?.color ?? 'vanilla'} className={styles.valueBadge}>
-		{options?.prefix}
-		<span className={styles.badgeText} title={value}>
-			{value}
-		</span>
-	</Badge>
-);
-
-export const LOG_HIGHLIGHTS: LogHighlightConfig[] = [
-	{
-		key: 'service',
-		label: 'SERVICE',
-		render: (log): ReactNode | null => {
-			const value = getAttr(log, 'service.name');
-			return value
-				? valueBadge(value, {
-						prefix: <span className={styles.serviceDot} />,
-					})
-				: null;
-		},
-	},
-	{
-		key: 'severity',
-		label: 'SEVERITY',
-		render: (log): ReactNode | null => {
-			if (!log.severity_text) {
-				return null;
-			}
-			return valueBadge(log.severity_text, {
-				color: SEVERITY_COLOR[getLogIndicatorType(log)] ?? 'vanilla',
-			});
-		},
-	},
-	{
-		key: 'namespace',
-		label: 'NAMESPACE',
-		render: (log): ReactNode | null => {
-			const value = getAttr(log, 'service.namespace');
-			return value ? valueBadge(value) : null;
-		},
-	},
-	{
-		key: 'environment',
-		label: 'ENVIRONMENT',
-		render: (log): ReactNode | null => {
-			const value = getAttr(log, 'deployment.environment');
-			return value ? valueBadge(value) : null;
-		},
-	},
-	{
-		key: 'traceId',
-		label: 'TRACE ID',
-		render: (log): ReactNode | null => {
-			const traceId = log.trace_id || log.traceId;
-			return traceId ? <TraceIdField traceId={traceId} /> : null;
-		},
-	},
-	{
-		key: 'spanId',
-		label: 'SPAN ID',
-		render: (log): ReactNode | null => {
-			const spanId = log.span_id || log.spanID;
-			return spanId ? valueBadge(spanId) : null;
-		},
-	},
-];

frontend/src/components/LogDetail/__tests__/LogDetail.test.tsx

@@ -115,45 +115,6 @@ describe('LogDetail drawer — header (isLogDetailsV2)', () => {
 		expect(screen.queryByText('Open in Explorer')).not.toBeInTheDocument();
 	});
 
-	it('renders Highlights for fields present on the log, omitting absent ones', () => {
-		const logWithMeta = {
-			...mockLog,
-			severity_text: 'ERROR',
-			trace_id: 'trace-abc',
-			resources_string: {
-				'service.name': 'checkout',
-				'deployment.environment': 'production',
-			},
-		} as unknown as ILog;
-
-		renderDrawer({ log: logWithMeta });
-
-		const highlights = screen.getByTestId('log-details-highlights');
-		expect(highlights).toHaveTextContent('SEVERITY');
-		expect(highlights).toHaveTextContent('ERROR');
-		expect(highlights).toHaveTextContent('SERVICE');
-		expect(highlights).toHaveTextContent('checkout');
-		expect(highlights).toHaveTextContent('ENVIRONMENT');
-		expect(highlights).toHaveTextContent('production');
-		expect(highlights).toHaveTextContent('TRACE ID');
-		// Absent fields are omitted (no namespace / span id on this log).
-		expect(highlights).not.toHaveTextContent('NAMESPACE');
-		expect(highlights).not.toHaveTextContent('SPAN ID');
-	});
-
-	it('links the trace id highlight to the trace detail in a new tab', () => {
-		const logWithTrace = {
-			...mockLog,
-			trace_id: 'trace-abc',
-		} as unknown as ILog;
-
-		renderDrawer({ log: logWithTrace });
-
-		const link = screen.getByRole('link', { name: 'trace-abc' });
-		expect(link).toHaveAttribute('target', '_blank');
-		expect(link.getAttribute('href')).toContain('/trace/trace-abc');
-	});
-
 	it('navigates to the next / previous log with the Down / Up arrow keys', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 		const logs = [makeLog('log-0'), makeLog('log-1'), makeLog('log-2')];

frontend/src/components/LogDetail/index.tsx

@@ -55,7 +55,6 @@ import { isLogDetailsV2, RESOURCE_KEYS, VIEW_TYPES, VIEWS } from './constants';
 import { LogDetailInnerProps, LogDetailProps } from './LogDetail.interfaces';
 import LogDetailsHeader from './LogDetailsHeader/LogDetailsHeader';
 import { useLogNavigation } from './LogDetailsHeader/useLogNavigation';
-import LogHighlights from './LogHighlights/LogHighlights';
 
 import './LogDetails.styles.scss';
 
@@ -400,8 +399,6 @@ function LogDetailInner({
 					<div className="log-overflow-shadow">&nbsp;</div>
 				</div>
 
-				{isLogDetailsV2 && <LogHighlights log={log} />}
-
 				<div className="tabs-and-search">
 					<ToggleGroupSimple
 						type="single"

pkg/types/quickfiltertypes/filter.go

@@ -7,7 +7,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/uptrace/bun"
 )
@@ -32,12 +31,11 @@ func (enum *Signal) UnmarshalJSON(data []byte) error {
 }
 
 var (
-	SignalTraces          = Signal{valuer.NewString("traces")}
-	SignalLogs            = Signal{valuer.NewString("logs")}
-	SignalApiMonitoring   = Signal{valuer.NewString("api_monitoring")}
-	SignalExceptions      = Signal{valuer.NewString("exceptions")}
-	SignalMeter           = Signal{valuer.NewString("meter")}
-	SignalAiObservability = Signal{valuer.NewString("ai_observability")}
+	SignalTraces        = Signal{valuer.NewString("traces")}
+	SignalLogs          = Signal{valuer.NewString("logs")}
+	SignalApiMonitoring = Signal{valuer.NewString("api_monitoring")}
+	SignalExceptions    = Signal{valuer.NewString("exceptions")}
+	SignalMeter         = Signal{valuer.NewString("meter")}
 )
 
 // NewSignal creates a Signal from a string.
@@ -53,8 +51,6 @@ func NewSignal(s string) (Signal, error) {
 		return SignalExceptions, nil
 	case "meter":
 		return SignalMeter, nil
-	case "ai_observability":
-		return SignalAiObservability, nil
 	default:
 		return Signal{}, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid signal: %s", s)
 	}
@@ -191,18 +187,6 @@ func NewDefaultQuickFilter(orgID valuer.UUID) ([]*StorableQuickFilter, error) {
 		{"key": "host.name", "dataType": "float64", "type": "Sum"},
 	}
 
-	// AI observability (builder_ai_query trace explorer), ordered by expected
-	// usage: env scoping, the LLM identity keys, then service and the rest.
-	aiObservabilityFilters := []map[string]interface{}{
-		{"key": "deployment.environment", "dataType": "string", "type": "resource"},
-		{"key": telemetrytypes.GenAIOperationName, "dataType": "string", "type": "tag"},
-		{"key": telemetrytypes.GenAIProviderName, "dataType": "string", "type": "tag"},
-		{"key": telemetrytypes.GenAIRequestModel, "dataType": "string", "type": "tag"},
-		{"key": "service.name", "dataType": "string", "type": "resource"},
-		{"key": telemetrytypes.GenAIToolName, "dataType": "string", "type": "tag"},
-		{"key": telemetrytypes.GenAIAgentName, "dataType": "string", "type": "tag"},
-	}
-
 	tracesJSON, err := json.Marshal(tracesFilters)
 	if err != nil {
 		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal traces filters")
@@ -228,11 +212,6 @@ func NewDefaultQuickFilter(orgID valuer.UUID) ([]*StorableQuickFilter, error) {
 		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal meter filters")
 	}
 
-	aiObservabilityJSON, err := json.Marshal(aiObservabilityFilters)
-	if err != nil {
-		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal ai observability filters")
-	}
-
 	timeRightNow := time.Now()
 
 	return []*StorableQuickFilter{
@@ -296,17 +275,5 @@ func NewDefaultQuickFilter(orgID valuer.UUID) ([]*StorableQuickFilter, error) {
 				UpdatedAt: timeRightNow,
 			},
 		},
-		{
-			Identifiable: types.Identifiable{
-				ID: valuer.GenerateUUID(),
-			},
-			OrgID:  orgID,
-			Filter: string(aiObservabilityJSON),
-			Signal: SignalAiObservability,
-			TimeAuditable: types.TimeAuditable{
-				CreatedAt: timeRightNow,
-				UpdatedAt: timeRightNow,
-			},
-		},
 	}, nil
 }

pkg/types/telemetrytypes/genai_semconv.go

@@ -3,11 +3,10 @@ package telemetrytypes
 // OpenTelemetry gen_ai semantic-convention attribute keys. Single source of truth
 // shared by the AI query builder and the LLM pricing pipeline.
 const (
-	GenAIRequestModel  = "gen_ai.request.model"
-	GenAIOperationName = "gen_ai.operation.name"
-	GenAIToolName      = "gen_ai.tool.name"
-	GenAIAgentName     = "gen_ai.agent.name"
-	GenAIProviderName  = "gen_ai.provider.name"
+	GenAIRequestModel = "gen_ai.request.model"
+	GenAIToolName     = "gen_ai.tool.name"
+	GenAIAgentName    = "gen_ai.agent.name"
+	GenAIProviderName = "gen_ai.provider.name"
 
 	GenAIUsageInputTokens              = "gen_ai.usage.input_tokens"
 	GenAIUsageOutputTokens             = "gen_ai.usage.output_tokens"
@@ -26,11 +25,10 @@ const (
 // on, surfaced by the metadata store even before ingestion so the AI gate/columns
 // resolve on a fresh install.
 var GenAIFieldDefinitions = map[string]TelemetryFieldKey{
-	GenAIRequestModel:  {Name: GenAIRequestModel, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeString},
-	GenAIOperationName: {Name: GenAIOperationName, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeString},
-	GenAIToolName:      {Name: GenAIToolName, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeString},
-	GenAIAgentName:     {Name: GenAIAgentName, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeString},
-	GenAIProviderName:  {Name: GenAIProviderName, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeString},
+	GenAIRequestModel: {Name: GenAIRequestModel, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeString},
+	GenAIToolName:     {Name: GenAIToolName, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeString},
+	GenAIAgentName:    {Name: GenAIAgentName, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeString},
+	GenAIProviderName: {Name: GenAIProviderName, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeString},
 
 	GenAIUsageInputTokens:              {Name: GenAIUsageInputTokens, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeFloat64},
 	GenAIUsageOutputTokens:             {Name: GenAIUsageOutputTokens, Signal: SignalTraces, FieldContext: FieldContextAttribute, FieldDataType: FieldDataTypeFloat64},

tests/fixtures/cloudintegrations.py

@@ -26,14 +26,14 @@ class ProviderAccountSpec:
     provider: str
     # params for the account created by default.
     initial_params: dict
-    # params for the config an update (PUT) test sends.
-    updated_params: dict
     # params -> the provider-keyed `config` block for a POST/PUT body.
     build_config: Callable[[dict], dict]
     # params -> the full config block the API is expected to return under
     # config[provider] on GET/list. This may differ from what build_config sends:
     # e.g. AWS accepts deploymentRegion on POST but the API does not echo it back.
     expected_config: Callable[[dict], dict]
+    # only the suites that exercise updates need to supply it.
+    updated_params: dict = field(default_factory=dict)
     # id shown in parametrized test names; defaults to the provider slug.
     id: str = field(default="")
 
@@ -42,6 +42,29 @@ class ProviderAccountSpec:
             object.__setattr__(self, "id", self.provider)
 
 
+# Per-provider service shape.
+@dataclass(frozen=True)
+class ProviderServiceSpec:
+    provider: str
+    service_id: str
+    # GCP ships every service with supportedSignals.logs false, so a logs block
+    # is neither required on write nor persisted.
+    supports_logs: bool
+    account_config: dict
+    # id shown in parametrized test names; defaults to the provider slug.
+    id: str = field(default="")
+
+    def __post_init__(self) -> None:
+        if not self.id:
+            object.__setattr__(self, "id", self.provider)
+
+    def build_service_config(self, metrics_enabled: bool, logs_enabled: bool | None = None) -> dict:
+        config: dict = {"metrics": {"enabled": metrics_enabled}}
+        if self.supports_logs:
+            config["logs"] = {"enabled": metrics_enabled if logs_enabled is None else logs_enabled}
+        return {self.provider: config}
+
+
 @pytest.fixture(scope="function")
 def deprecated_create_cloud_integration_account(
     request: pytest.FixtureRequest,

tests/integration/tests/cloudintegrations/02_create_account.py

@@ -1,14 +1,52 @@
 from collections.abc import Callable
 from http import HTTPStatus
 
+import pytest
 import requests
 
 from fixtures import types
 from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD, add_license
+from fixtures.cloudintegrations import ProviderAccountSpec
 from fixtures.logger import setup_logger
 
 logger = setup_logger(__name__)
 
+AWS_ACCOUNT_SPEC = ProviderAccountSpec(
+    provider="aws",
+    initial_params={"deployment_region": "us-east-1", "regions": ["us-east-1", "us-west-2"]},
+    build_config=lambda p: {"aws": {"deploymentRegion": p["deployment_region"], "regions": p["regions"]}},
+    expected_config=lambda p: {"regions": p["regions"]},
+)
+
+GCP_ACCOUNT_SPEC = ProviderAccountSpec(
+    provider="gcp",
+    initial_params={
+        "deployment_project_id": "signoz-test-project",
+        "deployment_region": "us-central1",
+        "project_ids": ["signoz-test-project"],
+    },
+    build_config=lambda p: {
+        "gcp": {
+            "deploymentProjectId": p["deployment_project_id"],
+            "deploymentRegion": p["deployment_region"],
+            "projectIds": p["project_ids"],
+        }
+    },
+    expected_config=lambda p: {
+        "deploymentProjectId": p["deployment_project_id"],
+        "deploymentRegion": p["deployment_region"],
+        "projectIds": p["project_ids"],
+    },
+)
+
+PROVIDER_ACCOUNT_SPECS = [AWS_ACCOUNT_SPEC, GCP_ACCOUNT_SPEC]
+
+provider_spec = pytest.mark.parametrize(
+    "spec",
+    PROVIDER_ACCOUNT_SPECS,
+    ids=[s.id for s in PROVIDER_ACCOUNT_SPECS],
+)
+
 
 def test_apply_license(
     signoz: types.SigNoz,
@@ -20,19 +58,19 @@ def test_apply_license(
     add_license(signoz, make_http_mocks, get_token)
 
 
+@provider_spec
 def test_create_account(
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
     create_cloud_integration_account: Callable,
+    spec: ProviderAccountSpec,
 ) -> None:
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    cloud_provider = "aws"
 
     data = create_cloud_integration_account(
         admin_token,
-        cloud_provider,
-        deployment_region="us-east-1",
-        regions=["us-east-1", "us-west-2"],
+        spec.provider,
+        config=spec.build_config(spec.initial_params),
     )
 
     assert "id" in data, "Response data should contain 'id' field"
@@ -40,12 +78,17 @@ def test_create_account(
 
     assert "connectionArtifact" in data, "Response data should contain 'connectionArtifact' field"
     artifact = data["connectionArtifact"]
-    assert "aws" in artifact, "connectionArtifact should contain 'aws' field"
-    assert "connectionUrl" in artifact["aws"], "connectionArtifact.aws should contain 'connectionUrl'"
 
-    connection_url = artifact["aws"]["connectionUrl"]
-    assert "console.aws.amazon.com/cloudformation" in connection_url, "connectionUrl should be an AWS CloudFormation URL"
-    assert "region=us-east-1" in connection_url, "connectionUrl should contain the deployment region"
+    if spec.provider == "aws":
+        assert "aws" in artifact, "connectionArtifact should contain 'aws' field"
+        assert "connectionUrl" in artifact["aws"], "connectionArtifact.aws should contain 'connectionUrl'"
+
+        connection_url = artifact["aws"]["connectionUrl"]
+        assert "console.aws.amazon.com/cloudformation" in connection_url, "connectionUrl should be an AWS CloudFormation URL"
+        assert f"region={spec.initial_params['deployment_region']}" in connection_url, "connectionUrl should contain the deployment region"
+    else:
+        # GCP is a manual flow: no one-click install artifact.
+        assert artifact.get("gcp") is None, f"GCP should not return a connection artifact, got: {artifact}"
 
 
 def test_create_account_unsupported_provider(
@@ -76,3 +119,36 @@ def test_create_account_unsupported_provider(
 
     response_data = response.json()
     assert "error" in response_data, "Response should contain 'error' field"
+
+
+def test_create_gcp_account_without_project_ids(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+) -> None:
+    """GCP account config requires at least one project ID to monitor."""
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get("/api/v1/cloud_integrations/gcp/accounts"),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json={
+            "config": {
+                "gcp": {
+                    "deploymentProjectId": "signoz-test-project",
+                    "deploymentRegion": "us-central1",
+                    "projectIds": [],
+                }
+            },
+            "credentials": {
+                "sigNozApiURL": "https://test.signoz.cloud",
+                "sigNozApiKey": "test-key",
+                "ingestionUrl": "https://ingest.test.signoz.cloud",
+                "ingestionKey": "test-ingestion-key",
+            },
+        },
+        timeout=10,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, f"Expected 400 for empty projectIds, got {response.status_code}: {response.text}"
+    assert "error" in response.json(), "Response should contain 'error' field"

tests/integration/tests/cloudintegrations/03_agent_check_in.py

@@ -2,14 +2,53 @@ import uuid
 from collections.abc import Callable
 from http import HTTPStatus
 
+import pytest
+
 from fixtures import types
 from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD, add_license
-from fixtures.cloudintegrations import simulate_agent_checkin
+from fixtures.cloudintegrations import (
+    ProviderAccountSpec,
+    simulate_agent_checkin,
+)
 from fixtures.logger import setup_logger
 
 logger = setup_logger(__name__)
 
-CLOUD_PROVIDER = "aws"
+AWS_ACCOUNT_SPEC = ProviderAccountSpec(
+    provider="aws",
+    initial_params={"deployment_region": "us-east-1", "regions": ["us-east-1"]},
+    build_config=lambda p: {"aws": {"deploymentRegion": p["deployment_region"], "regions": p["regions"]}},
+    expected_config=lambda p: {"regions": p["regions"]},
+)
+
+GCP_ACCOUNT_SPEC = ProviderAccountSpec(
+    provider="gcp",
+    initial_params={
+        "deployment_project_id": "signoz-test-project",
+        "deployment_region": "us-central1",
+        "project_ids": ["signoz-test-project"],
+    },
+    build_config=lambda p: {
+        "gcp": {
+            "deploymentProjectId": p["deployment_project_id"],
+            "deploymentRegion": p["deployment_region"],
+            "projectIds": p["project_ids"],
+        }
+    },
+    expected_config=lambda p: {
+        "deploymentProjectId": p["deployment_project_id"],
+        "deploymentRegion": p["deployment_region"],
+        "projectIds": p["project_ids"],
+    },
+)
+
+PROVIDER_ACCOUNT_SPECS = [AWS_ACCOUNT_SPEC, GCP_ACCOUNT_SPEC]
+
+provider_spec = pytest.mark.parametrize(
+    "spec",
+    PROVIDER_ACCOUNT_SPECS,
+    ids=[s.id for s in PROVIDER_ACCOUNT_SPECS],
+)
 
 
 def test_apply_license(
@@ -22,22 +61,28 @@ def test_apply_license(
     add_license(signoz, make_http_mocks, get_token)
 
 
+@provider_spec
 def test_agent_check_in(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
     create_cloud_integration_account: Callable,
+    spec: ProviderAccountSpec,
 ) -> None:
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
 
-    account = create_cloud_integration_account(admin_token, CLOUD_PROVIDER, regions=["us-east-1"])
+    account = create_cloud_integration_account(
+        admin_token,
+        spec.provider,
+        config=spec.build_config(spec.initial_params),
+    )
     account_id = account["id"]
     provider_account_id = str(uuid.uuid4())
 
     response = simulate_agent_checkin(
         signoz,
         admin_token,
-        CLOUD_PROVIDER,
+        spec.provider,
         account_id,
         provider_account_id,
         data={"version": "v0.0.8"},
@@ -47,57 +92,63 @@ def test_agent_check_in(
 
     data = response.json()["data"]
 
-    # New camelCase fields
     assert data["cloudIntegrationId"] == account_id, "cloudIntegrationId should match"
     assert data["providerAccountId"] == provider_account_id, "providerAccountId should match"
     assert "integrationConfig" in data, "Response should contain 'integrationConfig'"
     assert data["removedAt"] is None, "removedAt should be null for a live account"
 
-    # Backward-compat snake_case fields
-    assert data["account_id"] == account_id, "account_id (compat) should match"
-    assert data["cloud_account_id"] == provider_account_id, "cloud_account_id (compat) should match"
-    assert "integration_config" in data, "Response should contain 'integration_config' (compat)"
-    assert "removed_at" in data, "Response should contain 'removed_at' (compat)"
+    if spec.provider == "aws":
+        # Backward compat for agents deployed before the camelCase response; AWS only.
+        assert data["account_id"] == account_id, "account_id (compat) should match"
+        assert data["cloud_account_id"] == provider_account_id, "cloud_account_id (compat) should match"
+        assert "integration_config" in data, "Response should contain 'integration_config' (compat)"
+        assert "removed_at" in data, "Response should contain 'removed_at' (compat)"
 
-    # integrationConfig should reflect the configured regions
-    integration_config = data["integrationConfig"]
-    assert "aws" in integration_config, "integrationConfig should contain 'aws' block"
-    assert integration_config["aws"]["enabledRegions"] == ["us-east-1"], "enabledRegions should match account config"
+        integration_config = data["integrationConfig"]
+        assert "aws" in integration_config, "integrationConfig should contain 'aws' block"
+        assert integration_config["aws"]["enabledRegions"] == spec.initial_params["regions"], "enabledRegions should match account config"
+    else:
+        # GCP is a manual flow: the agent carries its own configuration.
+        assert data["integrationConfig"].get("gcp") is None, f"GCP should not return an integration config, got: {data['integrationConfig']}"
 
 
+@provider_spec
 def test_agent_check_in_account_not_found(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
+    spec: ProviderAccountSpec,
 ) -> None:
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
     fake_id = str(uuid.uuid4())
 
-    response = simulate_agent_checkin(signoz, admin_token, CLOUD_PROVIDER, fake_id, str(uuid.uuid4()))
+    response = simulate_agent_checkin(signoz, admin_token, spec.provider, fake_id, str(uuid.uuid4()))
 
     assert response.status_code == HTTPStatus.NOT_FOUND, f"Expected 404, got {response.status_code}: {response.text}"
 
 
+@provider_spec
 def test_duplicate_cloud_account_checkins(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
     create_cloud_integration_account: Callable,
+    spec: ProviderAccountSpec,
 ) -> None:
     """Test that two different accounts cannot check in with the same providerAccountId."""
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
 
-    account1 = create_cloud_integration_account(admin_token, CLOUD_PROVIDER)
-    account2 = create_cloud_integration_account(admin_token, CLOUD_PROVIDER)
+    account1 = create_cloud_integration_account(admin_token, spec.provider, config=spec.build_config(spec.initial_params))
+    account2 = create_cloud_integration_account(admin_token, spec.provider, config=spec.build_config(spec.initial_params))
 
     assert account1["id"] != account2["id"], "Two accounts should have different IDs"
 
     same_provider_account_id = str(uuid.uuid4())
 
     # First check-in: account1 claims the provider account ID
-    response = simulate_agent_checkin(signoz, admin_token, CLOUD_PROVIDER, account1["id"], same_provider_account_id)
+    response = simulate_agent_checkin(signoz, admin_token, spec.provider, account1["id"], same_provider_account_id)
     assert response.status_code == HTTPStatus.OK, f"Expected 200 for first check-in, got {response.status_code}: {response.text}"
 
     # Second check-in: account2 tries to claim the same provider account ID → 409
-    response = simulate_agent_checkin(signoz, admin_token, CLOUD_PROVIDER, account2["id"], same_provider_account_id)
+    response = simulate_agent_checkin(signoz, admin_token, spec.provider, account2["id"], same_provider_account_id)
     assert response.status_code == HTTPStatus.CONFLICT, f"Expected 409 for duplicate providerAccountId, got {response.status_code}: {response.text}"

tests/integration/tests/cloudintegrations/05_services.py

@@ -2,18 +2,47 @@ import uuid
 from collections.abc import Callable
 from http import HTTPStatus
 
+import pytest
 import requests
 from sqlalchemy import bindparam, sql
 
 from fixtures import types
 from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD, add_license
-from fixtures.cloudintegrations import simulate_agent_checkin
+from fixtures.cloudintegrations import (
+    ProviderServiceSpec,
+    simulate_agent_checkin,
+)
 from fixtures.logger import setup_logger
 
 logger = setup_logger(__name__)
 
-CLOUD_PROVIDER = "aws"
-SERVICE_ID = "rds"
+AWS_SERVICE_SPEC = ProviderServiceSpec(
+    provider="aws",
+    service_id="rds",
+    supports_logs=True,
+    account_config={"aws": {"deploymentRegion": "us-east-1", "regions": ["us-east-1"]}},
+)
+
+GCP_SERVICE_SPEC = ProviderServiceSpec(
+    provider="gcp",
+    service_id="cloudsql_postgres",
+    supports_logs=False,
+    account_config={
+        "gcp": {
+            "deploymentProjectId": "signoz-test-project",
+            "deploymentRegion": "us-central1",
+            "projectIds": ["signoz-test-project"],
+        }
+    },
+)
+
+PROVIDER_SERVICE_SPECS = [AWS_SERVICE_SPEC, GCP_SERVICE_SPEC]
+
+provider_spec = pytest.mark.parametrize(
+    "spec",
+    PROVIDER_SERVICE_SPECS,
+    ids=[s.id for s in PROVIDER_SERVICE_SPECS],
+)
 
 
 def test_apply_license(
@@ -26,16 +55,18 @@ def test_apply_license(
     add_license(signoz, make_http_mocks, get_token)
 
 
+@provider_spec
 def test_list_services_without_account(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
+    spec: ProviderServiceSpec,
 ) -> None:
     """List the cloud provider's supported services"""
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
 
     response = requests.get(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/services"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/services"),
         headers={"Authorization": f"Bearer {admin_token}"},
         timeout=10,
     )
@@ -53,35 +84,37 @@ def test_list_services_without_account(
     assert "icon" in service, "Service should have 'icon' field"
     assert "enabled" in service, "Service should have 'enabled' field"
 
-
-EC2_SERVICE_ID = "ec2"
+    listed_ids = {s["id"] for s in data["services"]}
+    assert spec.service_id in listed_ids, f"'{spec.service_id}' should be listed for {spec.provider}"
 
 
+@provider_spec
 def test_list_account_services(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
     create_cloud_integration_account: Callable,
+    spec: ProviderServiceSpec,
 ) -> None:
-    """ListAccountServicesMetadata reflects enabled state after enabling a service."""
+    """ListAccountServicesMetadata reflects enabled state per service."""
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
 
-    account = create_cloud_integration_account(admin_token, CLOUD_PROVIDER)
+    account = create_cloud_integration_account(admin_token, spec.provider, config=spec.account_config)
     account_id = account["id"]
 
-    checkin = simulate_agent_checkin(signoz, admin_token, CLOUD_PROVIDER, account_id, str(uuid.uuid4()))
+    checkin = simulate_agent_checkin(signoz, admin_token, spec.provider, account_id, str(uuid.uuid4()))
     assert checkin.status_code == HTTPStatus.OK, f"Check-in failed: {checkin.text}"
 
     put_response = requests.put(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}/services/{EC2_SERVICE_ID}"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}/services/{spec.service_id}"),
         headers={"Authorization": f"Bearer {admin_token}"},
-        json={"config": {"aws": {"metrics": {"enabled": True}, "logs": {"enabled": True}}}},
+        json={"config": spec.build_service_config(True)},
         timeout=10,
     )
-    assert put_response.status_code == HTTPStatus.NO_CONTENT, f"Enable ec2 failed: {put_response.status_code}: {put_response.text}"
+    assert put_response.status_code == HTTPStatus.NO_CONTENT, f"Enable {spec.service_id} failed: {put_response.status_code}: {put_response.text}"
 
     list_response = requests.get(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}/services"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}/services"),
         headers={"Authorization": f"Bearer {admin_token}"},
         timeout=10,
     )
@@ -92,21 +125,28 @@ def test_list_account_services(
     assert isinstance(data["services"], list), "services should be a list"
     assert len(data["services"]) > 0, "services list should be non-empty"
 
-    ec2_service = next((s for s in data["services"] if s["id"] == EC2_SERVICE_ID), None)
-    assert ec2_service is not None, f"EC2 service '{EC2_SERVICE_ID}' not found in services list"
-    assert ec2_service["enabled"] is True, f"EC2 service should be enabled, got: {ec2_service['enabled']}"
+    enabled_service = next((s for s in data["services"] if s["id"] == spec.service_id), None)
+    assert enabled_service is not None, f"Service '{spec.service_id}' not found in services list"
+    assert enabled_service["enabled"] is True, f"Service should be enabled, got: {enabled_service['enabled']}"
+
+    # The listing must report state per service, not blanket-enable or echo the write.
+    untouched_service = next((s for s in data["services"] if s["id"] != spec.service_id), None)
+    assert untouched_service is not None, "Expected more than one service in the listing"
+    assert untouched_service["enabled"] is False, f"Service '{untouched_service['id']}' was never enabled, got: {untouched_service['enabled']}"
 
 
+@provider_spec
 def test_get_service_details_without_account(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
+    spec: ProviderServiceSpec,
 ) -> None:
     """Get full service definition without specifying an account."""
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
 
     response = requests.get(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/services/{SERVICE_ID}"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/services/{spec.service_id}"),
         headers={"Authorization": f"Bearer {admin_token}"},
         timeout=10,
     )
@@ -114,31 +154,36 @@ def test_get_service_details_without_account(
     assert response.status_code == HTTPStatus.OK, f"Expected 200, got {response.status_code}"
 
     data = response.json()["data"]
-    assert data["id"] == SERVICE_ID, f"id should be '{SERVICE_ID}'"
+    assert data["id"] == spec.service_id, f"id should be '{spec.service_id}'"
     assert "title" in data, "Service should have 'title'"
     assert "overview" in data, "Service should have 'overview' (markdown)"
     assert "assets" in data, "Service should have 'assets'"
     assert isinstance(data["assets"]["dashboards"], list), "assets.dashboards should be a list"
     assert data["cloudIntegrationService"] is None, "cloudIntegrationService should be null without account context"
 
+    assert data["supportedSignals"]["metrics"] is True, "metrics should be a supported signal"
+    assert data["supportedSignals"]["logs"] is spec.supports_logs, f"logs support should be {spec.supports_logs} for {spec.provider}"
 
+
+@provider_spec
 def test_get_account_service(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
     create_cloud_integration_account: Callable,
+    spec: ProviderServiceSpec,
 ) -> None:
     """Get service for a specific account — all disabled by default."""
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
 
-    account = create_cloud_integration_account(admin_token, CLOUD_PROVIDER)
+    account = create_cloud_integration_account(admin_token, spec.provider, config=spec.account_config)
     account_id = account["id"]
 
-    checkin = simulate_agent_checkin(signoz, admin_token, CLOUD_PROVIDER, account_id, str(uuid.uuid4()))
+    checkin = simulate_agent_checkin(signoz, admin_token, spec.provider, account_id, str(uuid.uuid4()))
     assert checkin.status_code == HTTPStatus.OK, f"Check-in failed: {checkin.text}"
 
     response = requests.get(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}/services/{SERVICE_ID}"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}/services/{spec.service_id}"),
         headers={"Authorization": f"Bearer {admin_token}"},
         timeout=10,
     )
@@ -146,20 +191,22 @@ def test_get_account_service(
     assert response.status_code == HTTPStatus.OK, f"Expected 200, got {response.status_code}"
 
     data = response.json()["data"]
-    assert data["id"] == SERVICE_ID, f"id should be '{SERVICE_ID}'"
+    assert data["id"] == spec.service_id, f"id should be '{spec.service_id}'"
     assert data["cloudIntegrationService"] is None, "cloudIntegrationService should be null before any config is set"
 
 
+@provider_spec
 def test_get_service_not_found(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
+    spec: ProviderServiceSpec,
 ) -> None:
     """Get a non-existent service ID returns 400 (invalid service ID is a bad request)."""
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
 
     response = requests.get(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/services/non-existent-service"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/services/non-existent-service"),
         headers={"Authorization": f"Bearer {admin_token}"},
         timeout=10,
     )
@@ -167,32 +214,34 @@ def test_get_service_not_found(
     assert response.status_code == HTTPStatus.BAD_REQUEST, f"Expected 400, got {response.status_code}"
 
 
+@provider_spec
 def test_update_service_config(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
     create_cloud_integration_account: Callable,
+    spec: ProviderServiceSpec,
 ) -> None:
     """Enable a service and verify the config is persisted via GET."""
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
 
-    account = create_cloud_integration_account(admin_token, CLOUD_PROVIDER)
+    account = create_cloud_integration_account(admin_token, spec.provider, config=spec.account_config)
     account_id = account["id"]
 
-    checkin = simulate_agent_checkin(signoz, admin_token, CLOUD_PROVIDER, account_id, str(uuid.uuid4()))
+    checkin = simulate_agent_checkin(signoz, admin_token, spec.provider, account_id, str(uuid.uuid4()))
     assert checkin.status_code == HTTPStatus.OK, f"Check-in failed: {checkin.text}"
 
     put_response = requests.put(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}/services/{SERVICE_ID}"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}/services/{spec.service_id}"),
         headers={"Authorization": f"Bearer {admin_token}"},
-        json={"config": {"aws": {"metrics": {"enabled": True}, "logs": {"enabled": True}}}},
+        json={"config": spec.build_service_config(True)},
         timeout=10,
     )
 
     assert put_response.status_code == HTTPStatus.NO_CONTENT, f"Expected 204, got {put_response.status_code}: {put_response.text}"
 
     get_response = requests.get(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}/services/{SERVICE_ID}"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}/services/{spec.service_id}"),
         headers={"Authorization": f"Bearer {admin_token}"},
         timeout=10,
     )
@@ -201,33 +250,39 @@ def test_update_service_config(
     data = get_response.json()["data"]
     svc = data["cloudIntegrationService"]
     assert svc is not None, "cloudIntegrationService should be non-null after UpdateService"
-    assert svc["config"]["aws"]["metrics"]["enabled"] is True, "metrics should be enabled"
-    assert svc["config"]["aws"]["logs"]["enabled"] is True, "logs should be enabled"
+    assert svc["config"][spec.provider]["metrics"]["enabled"] is True, "metrics should be enabled"
     assert svc["cloudIntegrationId"] == account_id, "cloudIntegrationId should match the account"
 
+    if spec.supports_logs:
+        assert svc["config"][spec.provider]["logs"]["enabled"] is True, "logs should be enabled"
+    else:
+        assert svc["config"][spec.provider].get("logs") is None, f"logs should not be stored for {spec.provider}, got: {svc['config'][spec.provider]}"
 
+
+@provider_spec
 def test_update_service_config_disable(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
     create_cloud_integration_account: Callable,
+    spec: ProviderServiceSpec,
 ) -> None:
     """Enable then disable a service — config change is persisted."""
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
 
-    account = create_cloud_integration_account(admin_token, CLOUD_PROVIDER)
+    account = create_cloud_integration_account(admin_token, spec.provider, config=spec.account_config)
     account_id = account["id"]
 
-    checkin = simulate_agent_checkin(signoz, admin_token, CLOUD_PROVIDER, account_id, str(uuid.uuid4()))
+    checkin = simulate_agent_checkin(signoz, admin_token, spec.provider, account_id, str(uuid.uuid4()))
     assert checkin.status_code == HTTPStatus.OK, f"Check-in failed: {checkin.text}"
 
-    endpoint = signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}/services/{SERVICE_ID}")
+    endpoint = signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}/services/{spec.service_id}")
 
     # Enable
     r = requests.put(
         endpoint,
         headers={"Authorization": f"Bearer {admin_token}"},
-        json={"config": {"aws": {"metrics": {"enabled": True}, "logs": {"enabled": True}}}},
+        json={"config": spec.build_service_config(True)},
         timeout=10,
     )
     assert r.status_code == HTTPStatus.NO_CONTENT, f"Enable failed: {r.status_code}: {r.text}"
@@ -236,13 +291,13 @@ def test_update_service_config_disable(
     r = requests.put(
         endpoint,
         headers={"Authorization": f"Bearer {admin_token}"},
-        json={"config": {"aws": {"metrics": {"enabled": False}, "logs": {"enabled": False}}}},
+        json={"config": spec.build_service_config(False)},
         timeout=10,
     )
     assert r.status_code == HTTPStatus.NO_CONTENT, f"Disable failed: {r.status_code}: {r.text}"
 
     get_response = requests.get(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}/services/{SERVICE_ID}"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}/services/{spec.service_id}"),
         headers={"Authorization": f"Bearer {admin_token}"},
         timeout=10,
     )
@@ -250,28 +305,57 @@ def test_update_service_config_disable(
     assert get_response.status_code == HTTPStatus.OK
     svc = get_response.json()["data"]["cloudIntegrationService"]
     assert svc is not None, "cloudIntegrationService should still be present after disable"
-    assert svc["config"]["aws"]["metrics"]["enabled"] is False, "metrics should be disabled"
-    assert svc["config"]["aws"]["logs"]["enabled"] is False, "logs should be disabled"
+    assert svc["config"][spec.provider]["metrics"]["enabled"] is False, "metrics should be disabled"
+
+    if spec.supports_logs:
+        assert svc["config"][spec.provider]["logs"]["enabled"] is False, "logs should be disabled"
 
 
+@provider_spec
 def test_update_service_account_not_found(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
+    spec: ProviderServiceSpec,
 ) -> None:
     """PUT with a non-existent account UUID returns 404."""
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
 
     response = requests.put(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{uuid.uuid4()}/services/{SERVICE_ID}"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{uuid.uuid4()}/services/{spec.service_id}"),
         headers={"Authorization": f"Bearer {admin_token}"},
-        json={"config": {"aws": {"metrics": {"enabled": True}}}},
+        json={"config": spec.build_service_config(True)},
         timeout=10,
     )
 
     assert response.status_code == HTTPStatus.NOT_FOUND, f"Expected 404, got {response.status_code}"
 
 
+def test_update_gcp_service_without_metrics_config(
+    signoz: types.SigNoz,
+    create_user_admin: types.Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    create_cloud_integration_account: Callable,
+) -> None:
+    """GCP services support metrics only, so a config omitting metrics is rejected."""
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    account = create_cloud_integration_account(admin_token, "gcp", config=GCP_SERVICE_SPEC.account_config)
+    account_id = account["id"]
+
+    checkin = simulate_agent_checkin(signoz, admin_token, "gcp", account_id, str(uuid.uuid4()))
+    assert checkin.status_code == HTTPStatus.OK, f"Check-in failed: {checkin.text}"
+
+    response = requests.put(
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/gcp/accounts/{account_id}/services/{GCP_SERVICE_SPEC.service_id}"),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json={"config": {"gcp": {"logs": {"enabled": True}}}},
+        timeout=10,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, f"Expected 400 when metrics config is missing, got {response.status_code}: {response.text}"
+
+
 def test_list_services_unsupported_provider(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
@@ -289,30 +373,32 @@ def test_list_services_unsupported_provider(
     assert response.status_code == HTTPStatus.BAD_REQUEST, f"Expected 400, got {response.status_code}"
 
 
+@provider_spec
 def test_list_services_account_removed(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
     create_cloud_integration_account: Callable,
+    spec: ProviderServiceSpec,
 ) -> None:
     """List services for a deleted account returns 404."""
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
 
-    account = create_cloud_integration_account(admin_token, CLOUD_PROVIDER)
+    account = create_cloud_integration_account(admin_token, spec.provider, config=spec.account_config)
     account_id = account["id"]
 
-    checkin = simulate_agent_checkin(signoz, admin_token, CLOUD_PROVIDER, account_id, str(uuid.uuid4()))
+    checkin = simulate_agent_checkin(signoz, admin_token, spec.provider, account_id, str(uuid.uuid4()))
     assert checkin.status_code == HTTPStatus.OK, f"Check-in failed: {checkin.text}"
 
     delete_response = requests.delete(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}"),
         headers={"Authorization": f"Bearer {admin_token}"},
         timeout=10,
     )
     assert delete_response.status_code == HTTPStatus.NO_CONTENT, f"Expected 204 on delete, got {delete_response.status_code}"
 
     response = requests.get(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}/services"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}/services"),
         headers={"Authorization": f"Bearer {admin_token}"},
         timeout=10,
     )
@@ -320,30 +406,32 @@ def test_list_services_account_removed(
     assert response.status_code == HTTPStatus.NOT_FOUND, f"Expected 404, got {response.status_code}"
 
 
+@provider_spec
 def test_get_service_details_account_removed(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
     create_cloud_integration_account: Callable,
+    spec: ProviderServiceSpec,
 ) -> None:
     """Get service details for a deleted account returns 404."""
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
 
-    account = create_cloud_integration_account(admin_token, CLOUD_PROVIDER)
+    account = create_cloud_integration_account(admin_token, spec.provider, config=spec.account_config)
     account_id = account["id"]
 
-    checkin = simulate_agent_checkin(signoz, admin_token, CLOUD_PROVIDER, account_id, str(uuid.uuid4()))
+    checkin = simulate_agent_checkin(signoz, admin_token, spec.provider, account_id, str(uuid.uuid4()))
     assert checkin.status_code == HTTPStatus.OK, f"Check-in failed: {checkin.text}"
 
     delete_response = requests.delete(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}"),
         headers={"Authorization": f"Bearer {admin_token}"},
         timeout=10,
     )
     assert delete_response.status_code == HTTPStatus.NO_CONTENT, f"Expected 204 on delete, got {delete_response.status_code}"
 
     response = requests.get(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}/services/{SERVICE_ID}"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}/services/{spec.service_id}"),
         headers={"Authorization": f"Bearer {admin_token}"},
         timeout=10,
     )
@@ -351,64 +439,68 @@ def test_get_service_details_account_removed(
     assert response.status_code == HTTPStatus.NOT_FOUND, f"Expected 404, got {response.status_code}"
 
 
+@provider_spec
 def test_update_service_account_removed(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
     create_cloud_integration_account: Callable,
+    spec: ProviderServiceSpec,
 ) -> None:
     """PUT service config for a deleted account returns 404."""
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
 
-    account = create_cloud_integration_account(admin_token, CLOUD_PROVIDER)
+    account = create_cloud_integration_account(admin_token, spec.provider, config=spec.account_config)
     account_id = account["id"]
 
-    checkin = simulate_agent_checkin(signoz, admin_token, CLOUD_PROVIDER, account_id, str(uuid.uuid4()))
+    checkin = simulate_agent_checkin(signoz, admin_token, spec.provider, account_id, str(uuid.uuid4()))
     assert checkin.status_code == HTTPStatus.OK, f"Check-in failed: {checkin.text}"
 
     delete_response = requests.delete(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}"),
         headers={"Authorization": f"Bearer {admin_token}"},
         timeout=10,
     )
     assert delete_response.status_code == HTTPStatus.NO_CONTENT, f"Expected 204 on delete, got {delete_response.status_code}"
 
     response = requests.put(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}/services/{SERVICE_ID}"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}/services/{spec.service_id}"),
         headers={"Authorization": f"Bearer {admin_token}"},
-        json={"config": {"aws": {"metrics": {"enabled": True}}}},
+        json={"config": spec.build_service_config(True)},
         timeout=10,
     )
 
     assert response.status_code == HTTPStatus.NOT_FOUND, f"Expected 404, got {response.status_code}"
 
 
+@provider_spec
 def test_enable_metrics_provisions_dashboards(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
     create_cloud_integration_account: Callable,
+    spec: ProviderServiceSpec,
 ) -> None:
     """Enabling metrics provisions dashboards visible in GetService and present in the DB."""
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
 
-    account = create_cloud_integration_account(admin_token, CLOUD_PROVIDER)
+    account = create_cloud_integration_account(admin_token, spec.provider, config=spec.account_config)
     account_id = account["id"]
 
-    checkin = simulate_agent_checkin(signoz, admin_token, CLOUD_PROVIDER, account_id, str(uuid.uuid4()))
+    checkin = simulate_agent_checkin(signoz, admin_token, spec.provider, account_id, str(uuid.uuid4()))
     assert checkin.status_code == HTTPStatus.OK, f"Check-in failed: {checkin.text}"
 
     put_response = requests.put(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}/services/{SERVICE_ID}"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}/services/{spec.service_id}"),
         headers={"Authorization": f"Bearer {admin_token}"},
-        json={"config": {"aws": {"metrics": {"enabled": True}, "logs": {"enabled": False}}}},
+        json={"config": spec.build_service_config(True, logs_enabled=False)},
         timeout=10,
     )
     assert put_response.status_code == HTTPStatus.NO_CONTENT, f"Expected 204, got {put_response.status_code}: {put_response.text}"
 
     # Assertion 1: GetService returns provisioned dashboard UUIDs
     get_svc_response = requests.get(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}/services/{SERVICE_ID}"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}/services/{spec.service_id}"),
         headers={"Authorization": f"Bearer {admin_token}"},
         timeout=10,
     )
@@ -417,7 +509,7 @@ def test_enable_metrics_provisions_dashboards(
     data = get_svc_response.json()["data"]
     svc = data["cloudIntegrationService"]
     assert svc is not None, "cloudIntegrationService should be non-null after enabling metrics"
-    assert svc["config"]["aws"]["metrics"]["enabled"] is True
+    assert svc["config"][spec.provider]["metrics"]["enabled"] is True
 
     dashboards_in_service = data["assets"]["dashboards"]
     assert isinstance(dashboards_in_service, list) and len(dashboards_in_service) > 0, "assets.dashboards should be non-empty after enabling metrics"
@@ -445,35 +537,37 @@ def test_enable_metrics_provisions_dashboards(
     assert provisioned_ids == db_ids, f"Dashboards {provisioned_ids - db_ids} are missing from the DB"
 
 
+@provider_spec
 def test_disable_metrics_deprovisions_dashboards(
     signoz: types.SigNoz,
     create_user_admin: types.Operation,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
     create_cloud_integration_account: Callable,
+    spec: ProviderServiceSpec,
 ) -> None:
     """Disabling metrics removes provisioned dashboards from both GetService and the dashboards list."""
     admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
 
-    account = create_cloud_integration_account(admin_token, CLOUD_PROVIDER)
+    account = create_cloud_integration_account(admin_token, spec.provider, config=spec.account_config)
     account_id = account["id"]
 
-    checkin = simulate_agent_checkin(signoz, admin_token, CLOUD_PROVIDER, account_id, str(uuid.uuid4()))
+    checkin = simulate_agent_checkin(signoz, admin_token, spec.provider, account_id, str(uuid.uuid4()))
     assert checkin.status_code == HTTPStatus.OK, f"Check-in failed: {checkin.text}"
 
-    endpoint = signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}/services/{SERVICE_ID}")
+    endpoint = signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}/services/{spec.service_id}")
 
     # Enable metrics to provision dashboards first
     enable_response = requests.put(
         endpoint,
         headers={"Authorization": f"Bearer {admin_token}"},
-        json={"config": {"aws": {"metrics": {"enabled": True}, "logs": {"enabled": False}}}},
+        json={"config": spec.build_service_config(True, logs_enabled=False)},
         timeout=10,
     )
     assert enable_response.status_code == HTTPStatus.NO_CONTENT, f"Enable failed: {enable_response.status_code}: {enable_response.text}"
 
     # Capture the provisioned dashboard IDs before disabling
     get_svc_response = requests.get(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}/services/{SERVICE_ID}"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}/services/{spec.service_id}"),
         headers={"Authorization": f"Bearer {admin_token}"},
         timeout=10,
     )
@@ -485,14 +579,14 @@ def test_disable_metrics_deprovisions_dashboards(
     disable_response = requests.put(
         endpoint,
         headers={"Authorization": f"Bearer {admin_token}"},
-        json={"config": {"aws": {"metrics": {"enabled": False}, "logs": {"enabled": False}}}},
+        json={"config": spec.build_service_config(False)},
         timeout=10,
     )
     assert disable_response.status_code == HTTPStatus.NO_CONTENT, f"Disable failed: {disable_response.status_code}: {disable_response.text}"
 
     # Assertion 1: GetService no longer returns UUID dashboard IDs
     get_svc_after = requests.get(
-        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{CLOUD_PROVIDER}/accounts/{account_id}/services/{SERVICE_ID}"),
+        signoz.self.host_configs["8080"].get(f"/api/v1/cloud_integrations/{spec.provider}/accounts/{account_id}/services/{spec.service_id}"),
         headers={"Authorization": f"Bearer {admin_token}"},
         timeout=10,
     )