align system-dashboard with Source enums

assumption taken that system dashbard is just one which is going
tobe ai-o11y-overview page. (there is going to be a unique Name in
dashboard which would help us handle other system dashbaords)

no seeding code part present in this pr.

cmd/community/Dockerfile

@@ -11,7 +11,7 @@ RUN apk update && \
 
 
 COPY ./target/${OS}-${TARGETARCH}/signoz-community /root/signoz
-COPY ./templates /root/templates
+COPY ./templates/email /root/templates
 COPY frontend/build/ /etc/signoz/web/
 
 RUN chmod 755 /root /root/signoz

cmd/community/Dockerfile.multi-arch

@@ -12,7 +12,7 @@ RUN apk update && \
     rm -rf /var/cache/apk/*
 
 COPY ./target/${OS}-${ARCH}/signoz-community /root/signoz-community
-COPY ./templates /root/templates
+COPY ./templates/email /root/templates
 COPY frontend/build/ /etc/signoz/web/
 
 RUN chmod 755 /root /root/signoz-community

cmd/enterprise/Dockerfile

@@ -11,7 +11,7 @@ RUN apk update && \
 
 
 COPY ./target/${OS}-${TARGETARCH}/signoz /root/signoz
-COPY ./templates /root/templates
+COPY ./templates/email /root/templates
 COPY frontend/build/ /etc/signoz/web/
 
 RUN chmod 755 /root /root/signoz

cmd/enterprise/Dockerfile.integration

@@ -26,7 +26,7 @@ RUN go mod download
 COPY ./cmd/ ./cmd/
 COPY ./ee/ ./ee/
 COPY ./pkg/ ./pkg/
-COPY ./templates /root/templates
+COPY ./templates/email /root/templates
 
 COPY Makefile Makefile
 RUN TARGET_DIR=/root ARCHS=${TARGETARCH} ZEUS_URL=${ZEUSURL} LICENSE_URL=${ZEUSURL}/api/v1 make go-build-enterprise-race

cmd/enterprise/Dockerfile.multi-arch

@@ -12,7 +12,7 @@ RUN apk update && \
     rm -rf /var/cache/apk/*
 
 COPY ./target/${OS}-${ARCH}/signoz /root/signoz
-COPY ./templates /root/templates
+COPY ./templates/email /root/templates
 COPY frontend/build/ /etc/signoz/web/
 
 RUN chmod 755 /root /root/signoz

cmd/enterprise/Dockerfile.with-web.integration

@@ -35,7 +35,7 @@ RUN go mod download
 COPY ./cmd/ ./cmd/
 COPY ./ee/ ./ee/
 COPY ./pkg/ ./pkg/
-COPY ./templates /root/templates
+COPY ./templates/email /root/templates
 
 COPY Makefile Makefile
 RUN TARGET_DIR=/root ARCHS=${TARGETARCH} ZEUS_URL=${ZEUSURL} LICENSE_URL=${ZEUSURL}/api/v1 make go-build-enterprise-race

conf/example.yaml

@@ -182,11 +182,6 @@ alertmanager:
     poll_interval: 1m
     # The URL under which Alertmanager is externally reachable (for example, if Alertmanager is served via a reverse proxy). Used for generating relative and absolute links back to Alertmanager itself.
     external_url: http://localhost:8080
-    # The list of globs from which SigNoz's alertmanager notification templates are loaded (e.g. the email.signoz.html layout).
-    # This mirrors the upstream alertmanager `templates` config option. The upstream default templates (default.tmpl, email.tmpl)
-    # are always loaded from the embedded alertmanager assets, so only SigNoz's own templates need to be listed here.
-    templates:
-      - /opt/signoz/conf/templates/alertmanager/*.gotmpl
     # The global configuration for the alertmanager. All the exahustive fields can be found in the upstream: https://github.com/prometheus/alertmanager/blob/efa05feffd644ba4accb526e98a8c6545d26a783/config/config.go#L833
     global:
       # ResolveTimeout is the time after which an alert is declared resolved if it has not been updated.
@@ -434,17 +429,6 @@ tracedetail:
     max_depth_to_auto_expand: 5
     # Threshold below which all spans are returned without windowing.
     max_limit_to_select_all_spans: 10000
-  flamegraph:
-    # Maximum number of BFS depth levels included in a windowed response.
-    max_selected_levels: 50
-    # Maximum spans per level before sampling is applied.
-    max_spans_per_level: 100
-    # Number of highest-latency spans always included when sampling a level.
-    sampling_top_latency_count: 5
-    # Number of timestamp buckets used for uniform sampling within a level.
-    sampling_bucket_count: 50
-    # Threshold below which all spans are returned without windowing or sampling.
-    select_all_spans_limit: 100000
 
 ##################### Authz #################################
 authz:

docs/api/openapi.yml

@@ -18948,77 +18948,6 @@ paths:
       summary: Get waterfall view for a trace
       tags:
       - tracedetail
-  /api/v4/traces/{traceID}/waterfall:
-    post:
-      deprecated: false
-      description: Returns the waterfall view of spans including all spans if total
-        spans are under a limit, a max count otherwise. Aggregations are dropped compared
-        to v3
-      operationId: GetWaterfallV4
-      parameters:
-      - in: path
-        name: traceID
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/SpantypesPostableWaterfall'
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpantypesGettableWaterfallTrace'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: Get waterfall view for a trace
-      tags:
-      - tracedetail
   /api/v5/query_range:
     post:
       deprecated: false

ee/modules/cloudintegration/implcloudintegration/module.go

@@ -535,7 +535,7 @@ func (module *module) getOrCreateAPIKey(ctx context.Context, orgID valuer.UUID,
 func (module *module) provisionDashboards(ctx context.Context, orgID valuer.UUID, createdBy string, creator valuer.UUID, provider cloudintegrationtypes.CloudProviderType, service *cloudintegrationtypes.CloudIntegrationService, serviceDefinition *cloudintegrationtypes.ServiceDefinition) error {
 	// TODO: DB calls are in for loop, can be optimized later.
 	for _, dashboard := range serviceDefinition.Assets.Dashboards {
-		slug := cloudintegrationtypes.CloudIntegrationDashboardSlug(provider, service.Type, dashboard.ID)
+		slug := cloudintegrationtypes.IntegrationDashboardSlug(provider, service.Type, dashboard.ID)
 
 		existing, err := module.store.GetIntegrationDashboardBySlug(ctx, orgID, cloudintegrationtypes.IntegrationDashboardProviderCloudIntegration, slug)
 		if err != nil && !errors.Ast(err, errors.TypeNotFound) {
@@ -562,7 +562,7 @@ func (module *module) provisionDashboards(ctx context.Context, orgID valuer.UUID
 // deprovisionDashboards deletes all dashboard and integration_dashboard rows for the given service.
 // make sure to call this within a transaction.
 func (module *module) deprovisionDashboards(ctx context.Context, orgID valuer.UUID, provider cloudintegrationtypes.CloudProviderType, serviceID cloudintegrationtypes.ServiceID) error {
-	slugPrefix := cloudintegrationtypes.CloudIntegrationDashboardSlugPrefix(provider, serviceID)
+	slugPrefix := cloudintegrationtypes.IntegrationDashboardSlugPrefix(provider, serviceID)
 	rows, err := module.store.ListIntegrationDashboardsBySlugPrefix(ctx, orgID, cloudintegrationtypes.IntegrationDashboardProviderCloudIntegration, slugPrefix)
 	if err != nil {
 		return err
@@ -588,7 +588,7 @@ func (module *module) deprovisionDashboards(ctx context.Context, orgID valuer.UU
 // TODO: remove this hack and send idiomatic response to client.
 func (module *module) enrichDashboardIDs(ctx context.Context, orgID valuer.UUID, provider cloudintegrationtypes.CloudProviderType, serviceID cloudintegrationtypes.ServiceID, serviceDefinition *cloudintegrationtypes.ServiceDefinition) error {
 	for i, d := range serviceDefinition.Assets.Dashboards {
-		slug := cloudintegrationtypes.CloudIntegrationDashboardSlug(provider, serviceID, d.ID)
+		slug := cloudintegrationtypes.IntegrationDashboardSlug(provider, serviceID, d.ID)
 		row, err := module.store.GetIntegrationDashboardBySlug(ctx, orgID, cloudintegrationtypes.IntegrationDashboardProviderCloudIntegration, slug)
 		if err != nil {
 			if errors.Ast(err, errors.TypeNotFound) {

ee/modules/dashboard/impldashboard/module.go

@@ -228,6 +228,10 @@ func (module *module) Update(ctx context.Context, orgID valuer.UUID, id valuer.U
 	return module.pkgDashboardModule.Update(ctx, orgID, id, updatedBy, data, diff)
 }
 
+func (module *module) ResetSystemDashboard(ctx context.Context, orgID valuer.UUID, updatedBy string) (*dashboardtypes.Dashboard, error) {
+	return module.pkgDashboardModule.ResetSystemDashboard(ctx, orgID, updatedBy)
+}
+
 func (module *module) LockUnlock(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error {
 	return module.pkgDashboardModule.LockUnlock(ctx, orgID, id, updatedBy, isAdmin, lock)
 }

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

@@ -9,6 +9,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	baseapp "github.com/SigNoz/signoz/pkg/query-service/app"
+	"github.com/SigNoz/signoz/pkg/query-service/app/cloudintegrations"
 	"github.com/SigNoz/signoz/pkg/query-service/app/integrations"
 	"github.com/SigNoz/signoz/pkg/query-service/app/logparsingpipeline"
 	"github.com/SigNoz/signoz/pkg/query-service/interfaces"
@@ -23,6 +24,7 @@ type APIHandlerOptions struct {
 	DataConnector                 interfaces.Reader
 	UsageManager                  *usage.Manager
 	IntegrationsController        *integrations.Controller
+	CloudIntegrationsController   *cloudintegrations.Controller
 	LogsParsingPipelineController *logparsingpipeline.LogParsingPipelineController
 	GatewayUrl                    string
 	// Querier Influx Interval
@@ -40,6 +42,7 @@ func NewAPIHandler(opts APIHandlerOptions, signoz *signoz.SigNoz, config signoz.
 	baseHandler, err := baseapp.NewAPIHandler(baseapp.APIHandlerOpts{
 		Reader:                        opts.DataConnector,
 		IntegrationsController:        opts.IntegrationsController,
+		CloudIntegrationsController:   opts.CloudIntegrationsController,
 		LogsParsingPipelineController: opts.LogsParsingPipelineController,
 		FluxInterval:                  opts.FluxInterval,
 		LicensingAPI:                  httplicensing.NewLicensingAPI(signoz.Licensing),
@@ -88,6 +91,17 @@ func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 
 }
 
+func (ah *APIHandler) RegisterCloudIntegrationsRoutes(router *mux.Router, am *middleware.AuthZ) {
+
+	ah.APIHandler.RegisterCloudIntegrationsRoutes(router, am)
+
+	router.HandleFunc(
+		"/api/v1/cloud-integrations/{cloudProvider}/accounts/generate-connection-params",
+		am.EditAccess(ah.CloudIntegrationsGenerateConnectionParams),
+	).Methods(http.MethodGet)
+
+}
+
 func (ah *APIHandler) getVersion(w http.ResponseWriter, r *http.Request) {
 	versionResponse := basemodel.GetVersionResponse{
 		Version:        version.Info.Version(),

ee/query-service/app/server.go

@@ -30,6 +30,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/agentConf"
 	baseapp "github.com/SigNoz/signoz/pkg/query-service/app"
 	"github.com/SigNoz/signoz/pkg/query-service/app/clickhouseReader"
+	"github.com/SigNoz/signoz/pkg/query-service/app/cloudintegrations"
 	"github.com/SigNoz/signoz/pkg/query-service/app/integrations"
 	"github.com/SigNoz/signoz/pkg/query-service/app/logparsingpipeline"
 	"github.com/SigNoz/signoz/pkg/query-service/app/opamp"
@@ -85,13 +86,20 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 	// initiate opamp
 	opAmpModel.Init(signoz.SQLStore, signoz.Instrumentation.Logger(), signoz.Modules.OrgGetter)
 
-	integrationsController, err := integrations.NewController(signoz.SQLStore, signoz.Modules.Dashboard)
+	integrationsController, err := integrations.NewController(signoz.SQLStore)
 	if err != nil {
 		return nil, fmt.Errorf(
 			"couldn't create integrations controller: %w", err,
 		)
 	}
 
+	cloudIntegrationsController, err := cloudintegrations.NewController(signoz.SQLStore)
+	if err != nil {
+		return nil, fmt.Errorf(
+			"couldn't create cloud provider integrations controller: %w", err,
+		)
+	}
+
 	// ingestion pipelines manager
 	logParsingPipelineController, err := logparsingpipeline.NewLogParsingPipelinesController(
 		signoz.SQLStore,
@@ -126,6 +134,7 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 		DataConnector:                 reader,
 		UsageManager:                  usageManager,
 		IntegrationsController:        integrationsController,
+		CloudIntegrationsController:   cloudIntegrationsController,
 		LogsParsingPipelineController: logParsingPipelineController,
 		FluxInterval:                  config.Querier.FluxInterval,
 		GatewayUrl:                    config.Gateway.URL.String(),
@@ -191,6 +200,7 @@ func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*h
 	apiHandler.RegisterRoutes(r, am)
 	apiHandler.RegisterLogsRoutes(r, am)
 	apiHandler.RegisterIntegrationRoutes(r, am)
+	apiHandler.RegisterCloudIntegrationsRoutes(r, am)
 	apiHandler.RegisterQueryRangeV3Routes(r, am)
 	apiHandler.RegisterInfraMetricsRoutes(r, am)
 	apiHandler.RegisterQueryRangeV4Routes(r, am)

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

@@ -9232,17 +9232,6 @@ export type GetWaterfall200 = {
 	status: string;
 };
 
-export type GetWaterfallV4PathParameters = {
-	traceID: string;
-};
-export type GetWaterfallV4200 = {
-	data: SpantypesGettableWaterfallTraceDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type QueryRangeV5200 = {
 	data: Querybuildertypesv5QueryRangeResponseDTO;
 	/**

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

@@ -14,8 +14,6 @@ import type {
 import type {
 	GetWaterfall200,
 	GetWaterfallPathParameters,
-	GetWaterfallV4200,
-	GetWaterfallV4PathParameters,
 	RenderErrorResponseDTO,
 	SpantypesPostableWaterfallDTO,
 } from '../sigNoz.schemas';
@@ -122,102 +120,3 @@ export const useGetWaterfall = <
 > => {
 	return useMutation(getGetWaterfallMutationOptions(options));
 };
-/**
- * Returns the waterfall view of spans including all spans if total spans are under a limit, a max count otherwise. Aggregations are dropped compared to v3
- * @summary Get waterfall view for a trace
- */
-export const getWaterfallV4 = (
-	{ traceID }: GetWaterfallV4PathParameters,
-	spantypesPostableWaterfallDTO?: BodyType<SpantypesPostableWaterfallDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetWaterfallV4200>({
-		url: `/api/v4/traces/${traceID}/waterfall`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: spantypesPostableWaterfallDTO,
-		signal,
-	});
-};
-
-export const getGetWaterfallV4MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof getWaterfallV4>>,
-		TError,
-		{
-			pathParams: GetWaterfallV4PathParameters;
-			data?: BodyType<SpantypesPostableWaterfallDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof getWaterfallV4>>,
-	TError,
-	{
-		pathParams: GetWaterfallV4PathParameters;
-		data?: BodyType<SpantypesPostableWaterfallDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['getWaterfallV4'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof getWaterfallV4>>,
-		{
-			pathParams: GetWaterfallV4PathParameters;
-			data?: BodyType<SpantypesPostableWaterfallDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return getWaterfallV4(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type GetWaterfallV4MutationResult = NonNullable<
-	Awaited<ReturnType<typeof getWaterfallV4>>
->;
-export type GetWaterfallV4MutationBody =
-	| BodyType<SpantypesPostableWaterfallDTO>
-	| undefined;
-export type GetWaterfallV4MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get waterfall view for a trace
- */
-export const useGetWaterfallV4 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof getWaterfallV4>>,
-		TError,
-		{
-			pathParams: GetWaterfallV4PathParameters;
-			data?: BodyType<SpantypesPostableWaterfallDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof getWaterfallV4>>,
-	TError,
-	{
-		pathParams: GetWaterfallV4PathParameters;
-		data?: BodyType<SpantypesPostableWaterfallDTO>;
-	},
-	TContext
-> => {
-	return useMutation(getGetWaterfallV4MutationOptions(options));
-};

frontend/src/constants/app.ts

@@ -10,6 +10,9 @@ export const DEFAULT_AUTH0_APP_REDIRECTION_PATH = ROUTES.APPLICATION;
 
 export const INVITE_MEMBERS_HASH = '#invite-team-members';
 
+export const SIGNOZ_UPGRADE_PLAN_URL =
+	'https://upgrade.signoz.io/upgrade-from-app';
+
 export const DASHBOARD_TIME_IN_DURATION = 'refreshInterval';
 
 export const DEFAULT_ENTITY_VERSION = 'v3';

frontend/src/container/AllAlertChannels/__tests__/CreateAlertChannelNormalUser.test.tsx

@@ -1,3 +1,4 @@
+import { SIGNOZ_UPGRADE_PLAN_URL } from 'constants/app';
 import CreateAlertChannels from 'container/CreateAlertChannels';
 import { ChannelType } from 'container/CreateAlertChannels/config';
 import {
@@ -312,6 +313,16 @@ describe('Create Alert Channel (Normal User)', () => {
 				expect(screen.getByText('Microsoft Teams')).toBeInTheDocument();
 			});
 
+			it.skip('Should check if the upgrade plan message is shown', () => {
+				expect(screen.getByText('Upgrade to a Paid Plan')).toBeInTheDocument();
+				expect(
+					screen.getByText(/This feature is available for paid plans only./),
+				).toBeInTheDocument();
+				const link = screen.getByRole('link', { name: 'Click here' });
+				expect(link).toBeInTheDocument();
+				expect(link).toHaveAttribute('href', SIGNOZ_UPGRADE_PLAN_URL);
+				expect(screen.getByText(/to Upgrade/)).toBeInTheDocument();
+			});
 			it('Should check if the form buttons are displayed properly (Save, Test, Back)', () => {
 				expect(
 					screen.getByRole('button', { name: 'button_save_channel' }),

frontend/src/container/DashboardContainer/visualization/panels/BarPanel/__tests__/utils.test.ts

@@ -1,282 +0,0 @@
-import { Widgets } from 'types/api/dashboard/getAll';
-import {
-	MetricRangePayloadProps,
-	MetricRangePayloadV3,
-} from 'types/api/metrics/getQueryRange';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-import { PanelMode } from '../../types';
-import { prepareBarPanelConfig } from '../utils';
-import { prepareChartData } from 'lib/uPlotV2/utils/dataUtils';
-
-jest.mock(
-	'container/DashboardContainer/visualization/panels/utils/legendVisibilityUtils',
-	() => ({
-		getStoredSeriesVisibility: jest.fn(),
-	}),
-);
-
-jest.mock('lib/uPlotLib/plugins/onClickPlugin', () => ({
-	__esModule: true,
-	default: jest.fn().mockReturnValue({ name: 'onClickPlugin' }),
-}));
-
-jest.mock('lib/dashboard/getQueryResults', () => ({
-	getLegend: jest.fn(
-		(_queryData: unknown, _query: unknown, labelName: string) =>
-			`legend-${labelName}`,
-	),
-}));
-
-jest.mock('lib/getLabelName', () => ({
-	__esModule: true,
-	default: jest.fn(
-		(_metric: unknown, _queryName: string, _legend: string) => 'baseLabel',
-	),
-}));
-
-jest.mock(
-	'container/DashboardContainer/visualization/charts/utils/stackSeriesUtils',
-	() => ({
-		getInitialStackedBands: jest.fn().mockReturnValue([]),
-	}),
-);
-
-const getLegendMock = jest.requireMock('lib/dashboard/getQueryResults')
-	.getLegend as jest.Mock;
-const getLabelNameMock = jest.requireMock('lib/getLabelName')
-	.default as jest.Mock;
-const getInitialStackedBandsMock = jest.requireMock(
-	'container/DashboardContainer/visualization/charts/utils/stackSeriesUtils',
-).getInitialStackedBands as jest.Mock;
-
-const createApiResponse = (
-	result: MetricRangePayloadProps['data']['result'] = [],
-): MetricRangePayloadProps => ({
-	data: {
-		result,
-		resultType: 'matrix',
-		newResult: null as unknown as MetricRangePayloadV3,
-	},
-});
-
-const createWidget = (overrides: Partial<Widgets> = {}): Widgets =>
-	({
-		id: 'widget-1',
-		yAxisUnit: 'ms',
-		isLogScale: false,
-		thresholds: [],
-		customLegendColors: {},
-		...overrides,
-	}) as Widgets;
-
-const defaultTimezone = {
-	name: 'UTC',
-	value: 'UTC',
-	offset: 'UTC',
-	searchIndex: 'UTC',
-};
-
-describe('BarPanel utils', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-		getLabelNameMock.mockReturnValue('baseLabel');
-		getLegendMock.mockImplementation(
-			(_queryData: unknown, _query: unknown, labelName: string) =>
-				`legend-${labelName}`,
-		);
-	});
-
-	describe('prepareBarPanelData', () => {
-		it('returns aligned data with timestamps and empty series when result is empty', () => {
-			const data = prepareChartData(createApiResponse([]));
-			expect(data).toHaveLength(1);
-			expect(data[0]).toStrictEqual([]);
-		});
-
-		it('returns timestamps and one series of y values for single series', () => {
-			const data = prepareChartData(
-				createApiResponse([
-					{
-						metric: {},
-						queryName: 'Q',
-						legend: 'Series A',
-						values: [
-							[1000, '10'],
-							[2000, '20'],
-						],
-					} as MetricRangePayloadProps['data']['result'][0],
-				]),
-			);
-			expect(data).toHaveLength(2);
-			expect(data[0]).toStrictEqual([1000, 2000]);
-			expect(data[1]).toStrictEqual([10, 20]);
-		});
-
-		it('merges timestamps and fills missing values with null for multiple series', () => {
-			const data = prepareChartData(
-				createApiResponse([
-					{
-						metric: {},
-						queryName: 'Q1',
-						values: [
-							[1000, '1'],
-							[3000, '3'],
-						],
-					} as MetricRangePayloadProps['data']['result'][0],
-					{
-						metric: {},
-						queryName: 'Q2',
-						values: [
-							[1000, '10'],
-							[2000, '20'],
-						],
-					} as MetricRangePayloadProps['data']['result'][0],
-				]),
-			);
-			expect(data[0]).toStrictEqual([1000, 2000, 3000]);
-			expect(data[1]).toStrictEqual([1, null, 3]);
-			expect(data[2]).toStrictEqual([10, 20, null]);
-		});
-	});
-
-	describe('prepareBarPanelConfig', () => {
-		const baseParams = {
-			widget: createWidget(),
-			isDarkMode: true,
-			currentQuery: {} as Query,
-			onClick: jest.fn(),
-			onDragSelect: jest.fn(),
-			apiResponse: createApiResponse(),
-			timezone: defaultTimezone,
-			panelMode: PanelMode.DASHBOARD_VIEW,
-		};
-
-		it('adds no series when apiResponse has empty result', () => {
-			const config = prepareBarPanelConfig(baseParams).getConfig();
-			expect(config.series).toHaveLength(1);
-		});
-
-		it('adds one series per result item', () => {
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q1',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-				{
-					metric: {},
-					queryName: 'Q2',
-					values: [[1000, '2']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-			const config = prepareBarPanelConfig({
-				...baseParams,
-				apiResponse,
-			}).getConfig();
-			expect(config.series).toHaveLength(3);
-		});
-
-		it('uses getLegend for label when currentQuery is provided', () => {
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q1',
-					legend: 'L1',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-			const config = prepareBarPanelConfig({
-				...baseParams,
-				apiResponse,
-				currentQuery: {} as Query,
-			}).getConfig();
-			expect(getLegendMock).toHaveBeenCalled();
-			expect(config.series?.[1]).toMatchObject({ label: 'legend-baseLabel' });
-		});
-
-		it('uses getLabelName for label when currentQuery is null', () => {
-			getLegendMock.mockReset();
-			const apiResponse = createApiResponse([
-				{
-					metric: { __name__: 'requests' },
-					queryName: 'Q1',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-			prepareBarPanelConfig({
-				...baseParams,
-				apiResponse,
-				currentQuery: null as unknown as Query,
-			});
-			expect(getLabelNameMock).toHaveBeenCalled();
-			expect(getLegendMock).not.toHaveBeenCalled();
-		});
-
-		it('passes result metric to each series for cross-panel sync', () => {
-			const metric = { host: 'server1', __name__: 'http_requests' };
-			const apiResponse = createApiResponse([
-				{
-					metric,
-					queryName: 'Q1',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-			const config = prepareBarPanelConfig({
-				...baseParams,
-				apiResponse,
-			}).getConfig();
-			expect(config.series?.[1]).toMatchObject({ metric });
-		});
-
-		it('uses widget customLegendColors for series stroke', () => {
-			const widget = createWidget({
-				customLegendColors: { 'legend-baseLabel': '#ff0000' },
-			});
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-			const config = prepareBarPanelConfig({
-				...baseParams,
-				widget,
-				apiResponse,
-			}).getConfig();
-			expect(config.series?.[1]).toMatchObject({ stroke: '#ff0000' });
-		});
-
-		it('calls getInitialStackedBands when widget is stackedBarChart', () => {
-			const widget = createWidget({ stackedBarChart: true });
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q1',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-				{
-					metric: {},
-					queryName: 'Q2',
-					values: [[1000, '2']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-			prepareBarPanelConfig({ ...baseParams, widget, apiResponse });
-			// seriesCount = result.length + 1 = 3
-			expect(getInitialStackedBandsMock).toHaveBeenCalledWith(3);
-		});
-
-		it('does not call getInitialStackedBands for non-stacked chart', () => {
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q1',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-			prepareBarPanelConfig({ ...baseParams, apiResponse });
-			expect(getInitialStackedBandsMock).not.toHaveBeenCalled();
-		});
-	});
-});

frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/__tests__/utils.test.ts

@@ -303,27 +303,6 @@ describe('TimeSeriesPanel utils', () => {
 			expect(seriesConfig!.stroke).toBe('#ff0000');
 		});
 
-		it('passes result metric to each series for cross-panel sync', () => {
-			const metric = { host: 'server1', __name__: 'cpu' };
-			const apiResponse = createApiResponse([
-				{
-					metric,
-					queryName: 'Q',
-					values: [
-						[1000, '1'],
-						[2000, '2'],
-					],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-
-			const config = prepareUPlotConfig({
-				...baseParams,
-				apiResponse,
-			}).getConfig();
-
-			expect(config.series?.[1]).toMatchObject({ metric });
-		});
-
 		it('adds multiple series when result has multiple items', () => {
 			const apiResponse = createApiResponse([
 				{

frontend/src/container/PlannedDowntime/PlannedDowntime.styles.scss

@@ -81,20 +81,6 @@
 		}
 	}
 
-	.alert-rule-scope {
-		margin-bottom: 12px;
-
-		.ant-radio-wrapper {
-			color: var(--l1-foreground);
-		}
-	}
-
-	.alert-rule-all-warning {
-		font-size: 12px;
-		font-weight: 400;
-		color: var(--l2-foreground);
-	}
-
 	.formItemWithBullet {
 		margin-bottom: 0;
 	}

frontend/src/container/PlannedDowntime/PlannedDowntimeForm.tsx

@@ -8,7 +8,6 @@ import {
 	FormInstance,
 	Input,
 	Modal,
-	Radio,
 	Select,
 	SelectProps,
 	Spin,
@@ -72,14 +71,11 @@ const TZ_OPTIONS: DefaultOptionType[] = ALL_TIME_ZONES.map(
 	}),
 );
 
-type AlertRuleScope = 'all' | 'specific';
-
 interface PlannedDowntimeFormData {
 	name: string;
 	startTime: dayjs.Dayjs | null;
 	endTime: dayjs.Dayjs | null;
 	recurrence?: AlertmanagertypesRecurrenceDTO;
-	alertRuleScope: AlertRuleScope;
 	alertRules: DefaultOptionType[];
 	recurrenceSelect?: AlertmanagertypesRecurrenceDTO;
 	timezone?: string;
@@ -133,12 +129,6 @@ export function PlannedDowntimeForm(
 			recurrenceOptions.doesNotRepeat.value,
 	);
 
-	const [alertRuleScope, setAlertRuleScope] = useState<AlertRuleScope>(
-		initialValues.id && (initialValues.alertIds || []).length === 0
-			? 'all'
-			: 'specific',
-	);
-
 	const { notifications } = useNotifications();
 	const { showErrorModal } = useErrorModal();
 
@@ -152,12 +142,9 @@ export function PlannedDowntimeForm(
 	const saveHandler = useCallback(
 		async (values: PlannedDowntimeFormData) => {
 			const data: AlertmanagertypesPostablePlannedMaintenanceDTO = {
-				alertIds:
-					values.alertRuleScope === 'all'
-						? []
-						: (values.alertRules
-								.map((alert) => alert.value)
-								.filter((alert) => alert !== undefined) as string[]),
+				alertIds: values.alertRules
+					.map((alert) => alert.value)
+					.filter((alert) => alert !== undefined) as string[],
 				name: values.name,
 				scope: values.scope,
 				schedule: {
@@ -278,13 +265,12 @@ export function PlannedDowntimeForm(
 		const startTime = schedule?.recurrence?.startTime || schedule?.startTime;
 		const endTime = schedule?.recurrence?.endTime || schedule?.endTime;
 
-		const initialAlertIds = initialValues.alertIds || [];
-
 		return {
 			name: defaultTo(initialValues.name, ''),
-			alertRuleScope:
-				isEditMode && initialAlertIds.length === 0 ? 'all' : 'specific',
-			alertRules: getAlertOptionsFromIds(initialAlertIds, alertOptions),
+			alertRules: getAlertOptionsFromIds(
+				initialValues.alertIds || [],
+				alertOptions,
+			),
 			startTime: startTime ? dayjs(startTime).tz(schedule.timezone) : null,
 			endTime: endTime ? dayjs(endTime).tz(schedule.timezone) : null,
 			recurrence: {
@@ -301,7 +287,6 @@ export function PlannedDowntimeForm(
 
 	useEffect(() => {
 		setSelectedTags(formattedInitialValues.alertRules);
-		setAlertRuleScope(formattedInitialValues.alertRuleScope);
 		form.setFieldsValue({ ...formattedInitialValues });
 	}, [form, formattedInitialValues, initialValues]);
 
@@ -364,7 +349,6 @@ export function PlannedDowntimeForm(
 				onFinish={onFinish}
 				onValuesChange={(): void => {
 					setRecurrenceType(form.getFieldValue('recurrence')?.repeatType as string);
-					setAlertRuleScope(form.getFieldValue('alertRuleScope') as AlertRuleScope);
 					handleFormData(form.getFieldsValue());
 				}}
 				autoComplete="off"
@@ -464,76 +448,49 @@ export function PlannedDowntimeForm(
 					<div className="scheduleTimeInfoText">{endTimeText}</div>
 				)}
 				<div>
-					<Typography style={{ marginBottom: 8 }}>Silence Alerts</Typography>
-					<Form.Item
-						name="alertRuleScope"
-						initialValue="specific"
-						className="alert-rule-scope"
-					>
-						<Radio.Group>
-							<Radio value="all">All alert rules</Radio>
-							<Radio value="specific">Specific alert rules</Radio>
-						</Radio.Group>
+					<div className="alert-rule-form">
+						<Typography style={{ marginBottom: 8 }}>Silence Alerts</Typography>
+						<Typography style={{ marginBottom: 8 }} className="alert-rule-info">
+							(Leave empty to silence all alerts)
+						</Typography>
+					</div>
+					<Form.Item noStyle shouldUpdate>
+						<AlertRuleTags
+							closable
+							selectedTags={selectedTags}
+							handleClose={handleClose}
+						/>
+					</Form.Item>
+					<Form.Item name={alertRuleFormName}>
+						<Select
+							placeholder="Search for alerts rules or groups..."
+							mode="multiple"
+							status={isError ? 'error' : undefined}
+							loading={isLoading}
+							tagRender={noTagRenderer}
+							onChange={handleAlertRulesChange}
+							showSearch
+							options={alertOptions}
+							filterOption={(input, option): boolean =>
+								(option?.label as string)?.toLowerCase()?.includes(input.toLowerCase())
+							}
+							notFoundContent={
+								isLoading ? (
+									<span>
+										<Spin size="small" /> Loading...
+									</span>
+								) : (
+									<span>No alert available.</span>
+								)
+							}
+						>
+							{alertOptions?.map((option) => (
+								<Select.Option key={option.value} value={option.value}>
+									{option.label}
+								</Select.Option>
+							))}
+						</Select>
 					</Form.Item>
-					{alertRuleScope === 'specific' && (
-						<>
-							<Form.Item noStyle shouldUpdate>
-								<AlertRuleTags
-									closable
-									selectedTags={selectedTags}
-									handleClose={handleClose}
-								/>
-							</Form.Item>
-							<Form.Item
-								name={alertRuleFormName}
-								rules={[
-									{
-										validator: async (
-											_rule,
-											value: DefaultOptionType[] | undefined,
-										): Promise<void> => {
-											if (!value || value.length === 0) {
-												throw new Error(
-													'Select at least one alert rule, or choose "All alert rules" to silence everything.',
-												);
-											}
-										},
-									},
-								]}
-							>
-								<Select
-									placeholder="Search for alert rules or groups..."
-									mode="multiple"
-									status={isError ? 'error' : undefined}
-									loading={isLoading}
-									tagRender={noTagRenderer}
-									onChange={handleAlertRulesChange}
-									showSearch
-									options={alertOptions}
-									filterOption={(input, option): boolean =>
-										(option?.label as string)
-											?.toLowerCase()
-											?.includes(input.toLowerCase())
-									}
-									notFoundContent={
-										isLoading ? (
-											<span>
-												<Spin size="small" /> Loading...
-											</span>
-										) : (
-											<span>No alert available.</span>
-										)
-									}
-								>
-									{alertOptions?.map((option) => (
-										<Select.Option key={option.value} value={option.value}>
-											{option.label}
-										</Select.Option>
-									))}
-								</Select>
-							</Form.Item>
-						</>
-					)}
 				</div>
 				<Form.Item
 					label={

frontend/src/container/PlannedDowntime/PlannedDowntimeList.tsx

@@ -204,7 +204,7 @@ export function CollapseListContent({
 						selectedTags={alertOptions}
 					/>
 				) : (
-					<Tag className="all-alerts-tag">All alert rules</Tag>
+					'-'
 				),
 			)}
 		</Flex>

frontend/src/container/QueryTable/Drilldown/__tests__/useBaseDrilldownNavigate.test.ts

@@ -1,296 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import ROUTES from 'constants/routes';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-import { getViewQuery } from '../drilldownUtils';
-import { AggregateData } from '../useAggregateDrilldown';
-import useBaseDrilldownNavigate, {
-	buildDrilldownUrl,
-	getRoute,
-} from '../useBaseDrilldownNavigate';
-
-const mockSafeNavigate = jest.fn();
-
-jest.mock('hooks/useSafeNavigate', () => ({
-	useSafeNavigate: (): { safeNavigate: typeof mockSafeNavigate } => ({
-		safeNavigate: mockSafeNavigate,
-	}),
-}));
-
-jest.mock('../drilldownUtils', () => ({
-	...jest.requireActual('../drilldownUtils'),
-	getViewQuery: jest.fn(),
-}));
-
-const mockGetViewQuery = getViewQuery as jest.Mock;
-
-// ─── Fixtures ────────────────────────────────────────────────────────────────
-
-const MOCK_QUERY: Query = {
-	id: 'q1',
-	queryType: 'builder' as any,
-	builder: {
-		queryData: [
-			{
-				queryName: 'A',
-				dataSource: 'metrics' as any,
-				groupBy: [],
-				expression: '',
-				disabled: false,
-				functions: [],
-				legend: '',
-				having: [],
-				limit: null,
-				stepInterval: undefined,
-				orderBy: [],
-			},
-		],
-		queryFormulas: [],
-		queryTraceOperator: [],
-	},
-	promql: [],
-	clickhouse_sql: [],
-};
-
-const MOCK_VIEW_QUERY: Query = {
-	...MOCK_QUERY,
-	builder: {
-		...MOCK_QUERY.builder,
-		queryData: [
-			{
-				...MOCK_QUERY.builder.queryData[0],
-				filters: { items: [], op: 'AND' },
-			},
-		],
-	},
-};
-
-const MOCK_AGGREGATE_DATA: AggregateData = {
-	queryName: 'A',
-	filters: [{ filterKey: 'service_name', filterValue: 'auth', operator: '=' }],
-	timeRange: { startTime: 1000000, endTime: 2000000 },
-};
-
-// ─── getRoute ─────────────────────────────────────────────────────────────────
-
-describe('getRoute', () => {
-	it.each([
-		['view_logs', ROUTES.LOGS_EXPLORER],
-		['view_metrics', ROUTES.METRICS_EXPLORER],
-		['view_traces', ROUTES.TRACES_EXPLORER],
-	])('maps %s to the correct explorer route', (key, expected) => {
-		expect(getRoute(key)).toBe(expected);
-	});
-
-	it('returns empty string for an unknown key', () => {
-		expect(getRoute('view_dashboard')).toBe('');
-	});
-});
-
-// ─── buildDrilldownUrl ────────────────────────────────────────────────────────
-
-describe('buildDrilldownUrl', () => {
-	beforeEach(() => {
-		mockGetViewQuery.mockReturnValue(MOCK_VIEW_QUERY);
-	});
-
-	afterEach(() => {
-		jest.clearAllMocks();
-	});
-
-	it('returns null for an unknown drilldown key', () => {
-		const url = buildDrilldownUrl(
-			MOCK_QUERY,
-			MOCK_AGGREGATE_DATA,
-			'view_dashboard',
-		);
-		expect(url).toBeNull();
-	});
-
-	it('returns null when getViewQuery returns null', () => {
-		mockGetViewQuery.mockReturnValue(null);
-		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
-		expect(url).toBeNull();
-	});
-
-	it('returns a URL starting with the logs explorer route for view_logs', () => {
-		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
-		expect(url).not.toBeNull();
-		expect(url).toContain(ROUTES.LOGS_EXPLORER);
-	});
-
-	it('returns a URL starting with the traces explorer route for view_traces', () => {
-		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_traces');
-		expect(url).toContain(ROUTES.TRACES_EXPLORER);
-	});
-
-	it('includes compositeQuery param in the URL', () => {
-		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
-		expect(url).toContain('compositeQuery=');
-	});
-
-	it('includes startTime and endTime when aggregateData has a timeRange', () => {
-		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
-		expect(url).toContain('startTime=1000000');
-		expect(url).toContain('endTime=2000000');
-	});
-
-	it('omits startTime and endTime when aggregateData has no timeRange', () => {
-		const { timeRange: _, ...withoutTimeRange } = MOCK_AGGREGATE_DATA;
-		const url = buildDrilldownUrl(MOCK_QUERY, withoutTimeRange, 'view_logs');
-		expect(url).not.toContain('startTime=');
-		expect(url).not.toContain('endTime=');
-	});
-
-	it('includes summaryFilters param for view_metrics', () => {
-		const url = buildDrilldownUrl(
-			MOCK_QUERY,
-			MOCK_AGGREGATE_DATA,
-			'view_metrics',
-		);
-		expect(url).toContain(ROUTES.METRICS_EXPLORER);
-		expect(url).toContain('summaryFilters=');
-	});
-
-	it('does not include summaryFilters param for non-metrics routes', () => {
-		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
-		expect(url).not.toContain('summaryFilters=');
-	});
-
-	it('handles null aggregateData by passing empty filters and empty queryName', () => {
-		const url = buildDrilldownUrl(MOCK_QUERY, null, 'view_logs');
-		expect(url).not.toBeNull();
-		expect(mockGetViewQuery).toHaveBeenCalledWith(
-			MOCK_QUERY,
-			[],
-			'view_logs',
-			'',
-		);
-	});
-
-	it('passes aggregateData filters and queryName to getViewQuery', () => {
-		buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
-		expect(mockGetViewQuery).toHaveBeenCalledWith(
-			MOCK_QUERY,
-			MOCK_AGGREGATE_DATA.filters,
-			'view_logs',
-			MOCK_AGGREGATE_DATA.queryName,
-		);
-	});
-});
-
-// ─── useBaseDrilldownNavigate ─────────────────────────────────────────────────
-
-describe('useBaseDrilldownNavigate', () => {
-	beforeEach(() => {
-		mockGetViewQuery.mockReturnValue(MOCK_VIEW_QUERY);
-	});
-
-	afterEach(() => {
-		jest.clearAllMocks();
-	});
-
-	it('calls safeNavigate with the built URL on a valid key', () => {
-		const { result } = renderHook(() =>
-			useBaseDrilldownNavigate({
-				resolvedQuery: MOCK_QUERY,
-				aggregateData: MOCK_AGGREGATE_DATA,
-			}),
-		);
-
-		result.current('view_logs');
-
-		expect(mockSafeNavigate).toHaveBeenCalledTimes(1);
-		const [url] = mockSafeNavigate.mock.calls[0];
-		expect(url).toContain(ROUTES.LOGS_EXPLORER);
-		expect(url).toContain('compositeQuery=');
-	});
-
-	it('opens the explorer in a new tab', () => {
-		const { result } = renderHook(() =>
-			useBaseDrilldownNavigate({
-				resolvedQuery: MOCK_QUERY,
-				aggregateData: MOCK_AGGREGATE_DATA,
-			}),
-		);
-
-		result.current('view_traces');
-
-		expect(mockSafeNavigate).toHaveBeenCalledWith(expect.any(String), {
-			newTab: true,
-		});
-	});
-
-	it('calls callback after successful navigation', () => {
-		const callback = jest.fn();
-		const { result } = renderHook(() =>
-			useBaseDrilldownNavigate({
-				resolvedQuery: MOCK_QUERY,
-				aggregateData: MOCK_AGGREGATE_DATA,
-				callback,
-			}),
-		);
-
-		result.current('view_logs');
-
-		expect(callback).toHaveBeenCalledTimes(1);
-	});
-
-	it('does not call safeNavigate for an unknown key', () => {
-		const { result } = renderHook(() =>
-			useBaseDrilldownNavigate({
-				resolvedQuery: MOCK_QUERY,
-				aggregateData: MOCK_AGGREGATE_DATA,
-			}),
-		);
-
-		result.current('view_dashboard');
-
-		expect(mockSafeNavigate).not.toHaveBeenCalled();
-	});
-
-	it('still calls callback when the key is unknown', () => {
-		const callback = jest.fn();
-		const { result } = renderHook(() =>
-			useBaseDrilldownNavigate({
-				resolvedQuery: MOCK_QUERY,
-				aggregateData: MOCK_AGGREGATE_DATA,
-				callback,
-			}),
-		);
-
-		result.current('view_dashboard');
-
-		expect(callback).toHaveBeenCalledTimes(1);
-		expect(mockSafeNavigate).not.toHaveBeenCalled();
-	});
-
-	it('still calls callback when getViewQuery returns null', () => {
-		mockGetViewQuery.mockReturnValue(null);
-		const callback = jest.fn();
-		const { result } = renderHook(() =>
-			useBaseDrilldownNavigate({
-				resolvedQuery: MOCK_QUERY,
-				aggregateData: MOCK_AGGREGATE_DATA,
-				callback,
-			}),
-		);
-
-		result.current('view_logs');
-
-		expect(callback).toHaveBeenCalledTimes(1);
-		expect(mockSafeNavigate).not.toHaveBeenCalled();
-	});
-
-	it('handles null aggregateData without throwing', () => {
-		const { result } = renderHook(() =>
-			useBaseDrilldownNavigate({
-				resolvedQuery: MOCK_QUERY,
-				aggregateData: null,
-			}),
-		);
-
-		expect(() => result.current('view_logs')).not.toThrow();
-		expect(mockSafeNavigate).toHaveBeenCalledTimes(1);
-	});
-});

frontend/src/container/QueryTable/Drilldown/drilldownUtils.tsx

@@ -168,7 +168,7 @@ export const getAggregateColumnHeader = (
 	};
 };
 
-export const getFiltersFromMetric = (metric: any): FilterData[] =>
+const getFiltersFromMetric = (metric: any): FilterData[] =>
 	Object.keys(metric).map((key) => ({
 		filterKey: key,
 		filterValue: metric[key],

frontend/src/container/QueryTable/Drilldown/useBaseAggregateOptions.tsx

@@ -2,10 +2,14 @@ import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useLocation } from 'react-router-dom';
 import { Link, Loader } from '@signozhq/icons';
 import OverlayScrollbar from 'components/OverlayScrollbar/OverlayScrollbar';
+import { QueryParams } from 'constants/query';
 import { PANEL_TYPES } from 'constants/queryBuilder';
+import ROUTES from 'constants/routes';
 import useUpdatedQuery from 'container/GridCardLayout/useResolveQuery';
 import { processContextLinks } from 'container/NewWidget/RightContainer/ContextLinks/utils';
 import useContextVariables from 'hooks/dashboard/useContextVariables';
+import { useSafeNavigate } from 'hooks/useSafeNavigate';
+import createQueryParams from 'lib/createQueryParams';
 import ContextMenu from 'periscope/components/ContextMenu';
 import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { ContextLinksData } from 'types/api/dashboard/getAll';
@@ -14,10 +18,9 @@ import { openInNewTab } from 'utils/navigation';
 
 import { ContextMenuItem } from './contextConfig';
 import { getDataLinks } from './dataLinksUtils';
-import { getAggregateColumnHeader } from './drilldownUtils';
+import { getAggregateColumnHeader, getViewQuery } from './drilldownUtils';
 import { getBaseContextConfig } from './menuOptions';
 import { AggregateData } from './useAggregateDrilldown';
-import useBaseDrilldownNavigate from './useBaseDrilldownNavigate';
 
 interface UseBaseAggregateOptionsProps {
 	query: Query;
@@ -35,6 +38,19 @@ interface BaseAggregateOptionsConfig {
 	items?: ContextMenuItem;
 }
 
+const getRoute = (key: string): string => {
+	switch (key) {
+		case 'view_logs':
+			return ROUTES.LOGS_EXPLORER;
+		case 'view_metrics':
+			return ROUTES.METRICS_EXPLORER;
+		case 'view_traces':
+			return ROUTES.TRACES_EXPLORER;
+		default:
+			return '';
+	}
+};
+
 const useBaseAggregateOptions = ({
 	query,
 	onClose,
@@ -70,6 +86,8 @@ const useBaseAggregateOptions = ({
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [query, aggregateData, panelType]);
 
+	const { safeNavigate } = useSafeNavigate();
+
 	// Use the new useContextVariables hook
 	const { processedVariables } = useContextVariables({
 		maxValues: 2,
@@ -103,16 +121,50 @@ const useBaseAggregateOptions = ({
 					{label}
 				</ContextMenu.Item>
 			));
-		} catch {
+		} catch (error) {
 			return [];
 		}
 	}, [contextLinks, processedVariables, onClose, aggregateData, query]);
 
-	const handleBaseDrilldown = useBaseDrilldownNavigate({
-		resolvedQuery,
-		aggregateData,
-		callback: onClose,
-	});
+	const handleBaseDrilldown = useCallback(
+		(key: string): void => {
+			const route = getRoute(key);
+			const timeRange = aggregateData?.timeRange;
+			const filtersToAdd = aggregateData?.filters || [];
+			const viewQuery = getViewQuery(
+				resolvedQuery,
+				filtersToAdd,
+				key,
+				aggregateData?.queryName || '',
+			);
+
+			let queryParams = {
+				[QueryParams.compositeQuery]: encodeURIComponent(JSON.stringify(viewQuery)),
+				...(timeRange && {
+					[QueryParams.startTime]: timeRange?.startTime.toString(),
+					[QueryParams.endTime]: timeRange?.endTime.toString(),
+				}),
+			} as Record<string, string>;
+
+			if (route === ROUTES.METRICS_EXPLORER) {
+				queryParams = {
+					...queryParams,
+					[QueryParams.summaryFilters]: JSON.stringify(
+						viewQuery?.builder.queryData[0].filters,
+					),
+				};
+			}
+
+			if (route) {
+				safeNavigate(`${route}?${createQueryParams(queryParams)}`, {
+					newTab: true,
+				});
+			}
+
+			onClose();
+		},
+		[resolvedQuery, safeNavigate, onClose, aggregateData],
+	);
 
 	const { pathname } = useLocation();
 

frontend/src/container/QueryTable/Drilldown/useBaseDrilldownNavigate.ts

@@ -1,117 +0,0 @@
-import { useCallback } from 'react';
-import { QueryParams } from 'constants/query';
-import ROUTES from 'constants/routes';
-import { useSafeNavigate } from 'hooks/useSafeNavigate';
-import createQueryParams from 'lib/createQueryParams';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-import { getViewQuery } from './drilldownUtils';
-import { AggregateData } from './useAggregateDrilldown';
-
-type DrilldownKey = 'view_logs' | 'view_metrics' | 'view_traces';
-
-const DRILLDOWN_ROUTE_MAP: Record<DrilldownKey, string> = {
-	view_logs: ROUTES.LOGS_EXPLORER,
-	view_metrics: ROUTES.METRICS_EXPLORER,
-	view_traces: ROUTES.TRACES_EXPLORER,
-};
-
-const getRoute = (key: string): string =>
-	DRILLDOWN_ROUTE_MAP[key as DrilldownKey] ?? '';
-
-interface UseBaseDrilldownNavigateProps {
-	resolvedQuery: Query;
-	aggregateData: AggregateData | null;
-	callback?: () => void;
-}
-
-const useBaseDrilldownNavigate = ({
-	resolvedQuery,
-	aggregateData,
-	callback,
-}: UseBaseDrilldownNavigateProps): ((key: string) => void) => {
-	const { safeNavigate } = useSafeNavigate();
-
-	return useCallback(
-		(key: string): void => {
-			const route = getRoute(key);
-			const viewQuery = getViewQuery(
-				resolvedQuery,
-				aggregateData?.filters ?? [],
-				key,
-				aggregateData?.queryName ?? '',
-			);
-
-			if (!viewQuery || !route) {
-				callback?.();
-				return;
-			}
-
-			const timeRange = aggregateData?.timeRange;
-			let queryParams: Record<string, string> = {
-				[QueryParams.compositeQuery]: encodeURIComponent(JSON.stringify(viewQuery)),
-				...(timeRange && {
-					[QueryParams.startTime]: timeRange.startTime.toString(),
-					[QueryParams.endTime]: timeRange.endTime.toString(),
-				}),
-			};
-
-			if (route === ROUTES.METRICS_EXPLORER) {
-				queryParams = {
-					...queryParams,
-					[QueryParams.summaryFilters]: JSON.stringify(
-						viewQuery.builder.queryData[0].filters,
-					),
-				};
-			}
-
-			safeNavigate(`${route}?${createQueryParams(queryParams)}`, {
-				newTab: true,
-			});
-
-			callback?.();
-		},
-		[resolvedQuery, safeNavigate, callback, aggregateData],
-	);
-};
-
-export function buildDrilldownUrl(
-	resolvedQuery: Query,
-	aggregateData: AggregateData | null,
-	key: string,
-): string | null {
-	const route = getRoute(key);
-	const viewQuery = getViewQuery(
-		resolvedQuery,
-		aggregateData?.filters ?? [],
-		key,
-		aggregateData?.queryName ?? '',
-	);
-
-	if (!viewQuery || !route) {
-		return null;
-	}
-
-	const timeRange = aggregateData?.timeRange;
-	let queryParams: Record<string, string> = {
-		[QueryParams.compositeQuery]: encodeURIComponent(JSON.stringify(viewQuery)),
-		...(timeRange && {
-			[QueryParams.startTime]: timeRange.startTime.toString(),
-			[QueryParams.endTime]: timeRange.endTime.toString(),
-		}),
-	};
-
-	if (route === ROUTES.METRICS_EXPLORER) {
-		queryParams = {
-			...queryParams,
-			[QueryParams.summaryFilters]: JSON.stringify(
-				viewQuery.builder.queryData[0].filters,
-			),
-		};
-	}
-
-	return `${route}?${createQueryParams(queryParams)}`;
-}
-
-export { getRoute };
-export default useBaseDrilldownNavigate;

frontend/src/lib/uPlotV2/plugins/TooltipPlugin/__tests__/syncCursorRegistry.test.ts

@@ -1,29 +0,0 @@
-import { syncCursorRegistry } from '../syncCursorRegistry';
-
-describe('syncCursorRegistry', () => {
-	describe('metadata', () => {
-		it('returns undefined for unknown key', () => {
-			expect(syncCursorRegistry.getMetadata('unknown-meta')).toBeUndefined();
-		});
-
-		it('stores and retrieves metadata by syncKey', () => {
-			const metadata = { yAxisUnit: 'ms', groupBy: [] };
-			syncCursorRegistry.setMetadata('meta-key', metadata);
-			expect(syncCursorRegistry.getMetadata('meta-key')).toBe(metadata);
-		});
-	});
-
-	describe('activeSeriesMetric', () => {
-		it('returns null (not undefined) for unknown key', () => {
-			expect(
-				syncCursorRegistry.getActiveSeriesMetric('unknown-metric'),
-			).toBeNull();
-		});
-
-		it('stores and retrieves metric by syncKey', () => {
-			const metric = { host: 'server1', __name__: 'cpu' };
-			syncCursorRegistry.setActiveSeriesMetric('metric-key', metric);
-			expect(syncCursorRegistry.getActiveSeriesMetric('metric-key')).toBe(metric);
-		});
-	});
-});

frontend/src/lib/uPlotV2/plugins/TooltipPlugin/__tests__/syncDisplayHook.test.ts

@@ -1,627 +0,0 @@
-import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import uPlot from 'uplot';
-
-import { syncCursorRegistry } from '../syncCursorRegistry';
-import { createSyncDisplayHook } from '../syncDisplayHook';
-import {
-	SyncTooltipFilterMode,
-	type TooltipControllerState,
-	type TooltipSyncMetadata,
-} from '../types';
-
-jest.mock('../syncCursorRegistry', () => ({
-	syncCursorRegistry: {
-		setMetadata: jest.fn(),
-		getMetadata: jest.fn(),
-		setActiveSeriesMetric: jest.fn(),
-		getActiveSeriesMetric: jest.fn(),
-	},
-}));
-
-const mockRegistry = syncCursorRegistry as {
-	setMetadata: jest.Mock;
-	getMetadata: jest.Mock;
-	setActiveSeriesMetric: jest.Mock;
-	getActiveSeriesMetric: jest.Mock;
-};
-
-const SYNC_KEY = 'test-sync-key';
-
-// Builds a single-query groupByPerQuery from a list of dimension keys.
-const makeGroupByPerQuery = (
-	...keys: string[]
-): Record<string, BaseAutocompleteData[]> => ({
-	A: keys.map((key) => ({ key, type: 'tag' as const })),
-});
-
-function makeUPlotRoot(includeCrosshair = true): HTMLElement {
-	const root = document.createElement('div');
-	if (includeCrosshair) {
-		const el = document.createElement('div');
-		el.className = 'u-cursor-y';
-		root.append(el);
-	}
-	return root;
-}
-
-type FakeSeries = { metric?: Record<string, string>; show?: boolean };
-
-function makeFakeUPlot(opts: {
-	cursorEvent?: MouseEvent | null;
-	cursorLeft?: number;
-	series?: FakeSeries[];
-	includeCrosshair?: boolean;
-}): uPlot {
-	return {
-		root: makeUPlotRoot(opts.includeCrosshair ?? true),
-		cursor: {
-			event: opts.cursorEvent !== undefined ? opts.cursorEvent : null,
-			left: opts.cursorLeft ?? 50,
-		},
-		series: opts.series ?? [
-			{},
-			{ metric: { host: 'server1' } },
-			{ metric: { host: 'server2' } },
-		],
-		setSeries: jest.fn(),
-	} as unknown as uPlot;
-}
-
-function makeController(
-	focusedSeriesIndex: number | null = null,
-): TooltipControllerState {
-	return {
-		focusedSeriesIndex,
-		syncedSeriesIndexes: null,
-	} as TooltipControllerState;
-}
-
-// Convenience cast used throughout assertions.
-function mockSetSeries(u: uPlot): jest.Mock {
-	return (u as unknown as { setSeries: jest.Mock }).setSeries;
-}
-
-function getCrosshair(u: uPlot): HTMLElement {
-	const el = u.root.querySelector<HTMLElement>('.u-cursor-y');
-	if (!el) {
-		throw new Error('crosshair element missing');
-	}
-	return el;
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('createSyncDisplayHook', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-	});
-
-	// ── guard ────────────────────────────────────────────────────────────────
-
-	describe('no crosshair element', () => {
-		it('returns early without calling registry when .u-cursor-y absent', () => {
-			const hook = createSyncDisplayHook(SYNC_KEY, undefined, makeController());
-			const u = makeFakeUPlot({ includeCrosshair: false });
-			hook(u);
-			expect(mockRegistry.setMetadata).not.toHaveBeenCalled();
-			expect(mockRegistry.getMetadata).not.toHaveBeenCalled();
-			expect(mockSetSeries(u)).not.toHaveBeenCalled();
-		});
-	});
-
-	// ── source panel ─────────────────────────────────────────────────────────
-
-	describe('source behavior (cursor.event != null)', () => {
-		it('writes syncMetadata to registry', () => {
-			const syncMetadata: TooltipSyncMetadata = { yAxisUnit: 'ms' };
-			const hook = createSyncDisplayHook(SYNC_KEY, syncMetadata, makeController());
-			const u = makeFakeUPlot({ cursorEvent: new MouseEvent('mousemove') });
-			hook(u);
-			expect(mockRegistry.setMetadata).toHaveBeenCalledWith(
-				SYNC_KEY,
-				syncMetadata,
-			);
-		});
-
-		it('writes focused series metric when focusedSeriesIndex is set', () => {
-			const series: FakeSeries[] = [
-				{},
-				{ metric: { host: 'server1' } },
-				{ metric: { host: 'server2' } },
-			];
-			const hook = createSyncDisplayHook(SYNC_KEY, undefined, makeController(1));
-			const u = makeFakeUPlot({
-				cursorEvent: new MouseEvent('mousemove'),
-				series,
-			});
-			hook(u);
-			expect(mockRegistry.setActiveSeriesMetric).toHaveBeenCalledWith(SYNC_KEY, {
-				host: 'server1',
-			});
-		});
-
-		it('writes null metric when focusedSeriesIndex is null', () => {
-			const hook = createSyncDisplayHook(
-				SYNC_KEY,
-				undefined,
-				makeController(null),
-			);
-			const u = makeFakeUPlot({ cursorEvent: new MouseEvent('mousemove') });
-			hook(u);
-			expect(mockRegistry.setActiveSeriesMetric).toHaveBeenCalledWith(
-				SYNC_KEY,
-				null,
-			);
-		});
-
-		it('clears controller.syncedSeriesIndexes', () => {
-			const controller = makeController();
-			controller.syncedSeriesIndexes = [1, 2];
-			const hook = createSyncDisplayHook(SYNC_KEY, undefined, controller);
-			const u = makeFakeUPlot({ cursorEvent: new MouseEvent('mousemove') });
-			hook(u);
-			expect(controller.syncedSeriesIndexes).toBeNull();
-		});
-
-		it('shows crosshair and does not read from registry', () => {
-			const hook = createSyncDisplayHook(SYNC_KEY, undefined, makeController());
-			const u = makeFakeUPlot({ cursorEvent: new MouseEvent('mousemove') });
-			hook(u);
-			expect(getCrosshair(u).style.display).toBe('');
-			expect(mockRegistry.getMetadata).not.toHaveBeenCalled();
-		});
-	});
-
-	// ── receiver panel ───────────────────────────────────────────────────────
-
-	describe('receiver behavior (cursor.event is null)', () => {
-		describe('crosshair visibility', () => {
-			it('shows crosshair when yAxisUnit matches source', () => {
-				mockRegistry.getMetadata.mockReturnValue({ yAxisUnit: 'ms' });
-				mockRegistry.getActiveSeriesMetric.mockReturnValue(null);
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms' },
-					makeController(),
-				);
-				const u = makeFakeUPlot({ cursorEvent: null });
-				hook(u);
-				expect(getCrosshair(u).style.display).toBe('');
-			});
-
-			it('hides crosshair when yAxisUnit differs from source', () => {
-				mockRegistry.getMetadata.mockReturnValue({ yAxisUnit: 'bytes' });
-				mockRegistry.getActiveSeriesMetric.mockReturnValue(null);
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms' },
-					makeController(),
-				);
-				const u = makeFakeUPlot({ cursorEvent: null });
-				hook(u);
-				expect(getCrosshair(u).style.display).toBe('none');
-			});
-		});
-
-		// ── exact groupBy match ───────────────────────────────────────────────
-
-		describe('exact groupBy match', () => {
-			const groupByPerQuery = makeGroupByPerQuery('host');
-			const series: FakeSeries[] = [
-				{},
-				{ metric: { host: 'server1' } },
-				{ metric: { host: 'server2' } },
-			];
-
-			it('focuses the matching series and records it on the controller', () => {
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server2' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: 50, series });
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(2, { focus: true });
-				expect(controller.syncedSeriesIndexes).toStrictEqual([2]);
-			});
-
-			it('unfocuses all and emits empty matches (Filtered) when active metric is null', () => {
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue(null);
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: 50, series });
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(null, { focus: false });
-				expect(controller.syncedSeriesIndexes).toStrictEqual([]);
-			});
-
-			it('unfocuses all when metric matches no series', () => {
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({
-					host: 'unknown-server',
-				});
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: 50, series });
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(null, { focus: false });
-				expect(controller.syncedSeriesIndexes).toStrictEqual([]);
-			});
-
-			it('clears syncedSeriesIndexes when cursor is off-plot (left < 0)', () => {
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server1' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: -1, series });
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(null, { focus: false });
-				expect(controller.syncedSeriesIndexes).toBeNull();
-				expect(mockRegistry.getActiveSeriesMetric).not.toHaveBeenCalled();
-			});
-
-			it('never focuses series at index 0 (x-axis)', () => {
-				const sameMetric = { host: 'server1' };
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue(sameMetric);
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery },
-					controller,
-				);
-				const u = makeFakeUPlot({
-					cursorEvent: null,
-					cursorLeft: 50,
-					// Index 0 has the same metric — it must always be skipped.
-					series: [{ metric: sameMetric }, { metric: { host: 'other' } }],
-				});
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(null, { focus: false });
-				expect(controller.syncedSeriesIndexes).toStrictEqual([]);
-			});
-
-			it('skips hidden series (show === false)', () => {
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server1' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery },
-					controller,
-				);
-				const u = makeFakeUPlot({
-					cursorEvent: null,
-					cursorLeft: 50,
-					series: [
-						{},
-						{ metric: { host: 'server1' }, show: false },
-						{ metric: { host: 'server1' } },
-					],
-				});
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(2, { focus: true });
-				expect(controller.syncedSeriesIndexes).toStrictEqual([2]);
-			});
-		});
-
-		// ── partial groupBy overlap ───────────────────────────────────────────
-
-		describe('partial groupBy overlap', () => {
-			it('subset — records every receiver series matching on the common key', () => {
-				// Source groupBy=[host], receiver groupBy=[host, service].
-				// Hook focuses the first match; the rest are surfaced via controller.syncedSeriesIndexes.
-				const sourceGroupBy = makeGroupByPerQuery('host');
-				const receiverGroupBy = makeGroupByPerQuery('host', 'service');
-				const series: FakeSeries[] = [
-					{},
-					{ metric: { host: 'server1', service: 'api' } },
-					{ metric: { host: 'server1', service: 'frontend' } },
-					{ metric: { host: 'server2', service: 'api' } },
-				];
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery: sourceGroupBy,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server1' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery: receiverGroupBy },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: 50, series });
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(1, { focus: true });
-				expect(controller.syncedSeriesIndexes).toStrictEqual([1, 2]);
-			});
-
-			it('superset — records the one receiver series matching on the common key', () => {
-				// Source groupBy=[host, service], receiver groupBy=[host].
-				const sourceGroupBy = makeGroupByPerQuery('host', 'service');
-				const receiverGroupBy = makeGroupByPerQuery('host');
-				const series: FakeSeries[] = [
-					{},
-					{ metric: { host: 'server1' } },
-					{ metric: { host: 'server2' } },
-				];
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery: sourceGroupBy,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({
-					host: 'server1',
-					service: 'api',
-				});
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery: receiverGroupBy },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: 50, series });
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(1, { focus: true });
-				expect(controller.syncedSeriesIndexes).toStrictEqual([1]);
-			});
-
-			it('partial — matches on the intersecting key only', () => {
-				// Source groupBy=[host, service], receiver groupBy=[service, region].
-				// Common key is [service]. Both receiver series with service=api match.
-				const sourceGroupBy = makeGroupByPerQuery('host', 'service');
-				const receiverGroupBy = makeGroupByPerQuery('service', 'region');
-				const series: FakeSeries[] = [
-					{},
-					{ metric: { service: 'api', region: 'us-east' } },
-					{ metric: { service: 'api', region: 'eu-west' } },
-					{ metric: { service: 'frontend', region: 'us-east' } },
-				];
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery: sourceGroupBy,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({
-					host: 'server1',
-					service: 'api',
-				});
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery: receiverGroupBy },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: 50, series });
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(1, { focus: true });
-				expect(controller.syncedSeriesIndexes).toStrictEqual([1, 2]);
-			});
-		});
-
-		// ── union across queries in groupByPerQuery ───────────────────────────
-
-		describe('union across queries', () => {
-			it("treats the panel's effective groupBy as the union across its queries", () => {
-				// Source has query A=[host]; receiver has A=[host], B=[service].
-				// The shared key is `host` — receiver matches on that.
-				const sourceGroupBy: Record<string, BaseAutocompleteData[]> = {
-					A: [{ key: 'host', type: 'tag' }],
-				};
-				const receiverGroupBy: Record<string, BaseAutocompleteData[]> = {
-					A: [{ key: 'host', type: 'tag' }],
-					B: [{ key: 'service', type: 'tag' }],
-				};
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery: sourceGroupBy,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server1' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery: receiverGroupBy },
-					controller,
-				);
-				const u = makeFakeUPlot({
-					cursorEvent: null,
-					cursorLeft: 50,
-					series: [
-						{},
-						{ metric: { host: 'server1' } },
-						{ metric: { host: 'server2' } },
-					],
-				});
-				hook(u);
-				expect(controller.syncedSeriesIndexes).toStrictEqual([1]);
-			});
-		});
-
-		// ── no overlap (Filtered mode default) ────────────────────────────────
-
-		describe('no overlap → Filtered mode emits []', () => {
-			it('emits [] when groupBy keys are completely different', () => {
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery: makeGroupByPerQuery('host'),
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server1' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery: makeGroupByPerQuery('service') },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null });
-				hook(u);
-				expect(controller.syncedSeriesIndexes).toStrictEqual([]);
-			});
-
-			it('emits [] when receiver groupBy is empty', () => {
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery: makeGroupByPerQuery('host'),
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server1' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery: {} },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null });
-				hook(u);
-				expect(controller.syncedSeriesIndexes).toStrictEqual([]);
-			});
-
-			it('emits [] when source groupBy is absent', () => {
-				mockRegistry.getMetadata.mockReturnValue({ yAxisUnit: 'ms' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery: makeGroupByPerQuery('host') },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null });
-				hook(u);
-				expect(controller.syncedSeriesIndexes).toStrictEqual([]);
-			});
-		});
-
-		// ── filterMode: All ──────────────────────────────────────────────────
-
-		describe('filterMode All', () => {
-			it('emits null (no filter) when there is no overlap in groupBy', () => {
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery: makeGroupByPerQuery('host'),
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server1' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{
-						yAxisUnit: 'ms',
-						groupByPerQuery: makeGroupByPerQuery('service'),
-						filterMode: SyncTooltipFilterMode.All,
-					},
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null });
-				hook(u);
-				expect(controller.syncedSeriesIndexes).toBeNull();
-			});
-
-			it('emits null when metric matches no series', () => {
-				const groupByPerQuery = makeGroupByPerQuery('host');
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'unknown' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{
-						yAxisUnit: 'ms',
-						groupByPerQuery,
-						filterMode: SyncTooltipFilterMode.All,
-					},
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: 50 });
-				hook(u);
-				expect(controller.syncedSeriesIndexes).toBeNull();
-			});
-		});
-
-		// ── caching ───────────────────────────────────────────────────────────
-
-		describe('caching optimizations', () => {
-			it('reuses the crosshair element across multiple invocations', () => {
-				mockRegistry.getMetadata.mockReturnValue({ yAxisUnit: 'ms' });
-				mockRegistry.getActiveSeriesMetric.mockReturnValue(null);
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms' },
-					makeController(),
-				);
-				const u = makeFakeUPlot({ cursorEvent: null });
-				const spy = jest.spyOn(u.root, 'querySelector');
-				hook(u);
-				hook(u);
-				hook(u);
-				// querySelector should only be called once regardless of invocation count.
-				expect(spy).toHaveBeenCalledTimes(1);
-			});
-
-			it('recomputes common keys when source groupByPerQuery reference changes', () => {
-				const hostGroupBy = makeGroupByPerQuery('host');
-				const serviceGroupBy = makeGroupByPerQuery('service');
-				const series: FakeSeries[] = [
-					{},
-					{ metric: { host: 'server1', service: 'api' } },
-					{ metric: { host: 'server2', service: 'frontend' } },
-				];
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ groupByPerQuery: makeGroupByPerQuery('host', 'service') },
-					makeController(),
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: 50, series });
-
-				// First call: source groups by host → matches series 1.
-				mockRegistry.getMetadata.mockReturnValue({
-					groupByPerQuery: hostGroupBy,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server1' });
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(1, { focus: true });
-
-				jest.clearAllMocks();
-
-				// Second call: source now groups by service → matches series 2.
-				mockRegistry.getMetadata.mockReturnValue({
-					groupByPerQuery: serviceGroupBy,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({
-					service: 'frontend',
-				});
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(2, { focus: true });
-			});
-		});
-	});
-});

frontend/src/pages/TraceDetailsV3/SpanDetailsPanel/DockModeSwitcher.tsx

@@ -1,77 +0,0 @@
-import { ReactNode } from 'react';
-import { Dock, PanelBottom, PanelRight } from '@signozhq/icons';
-import { ToggleGroup, ToggleGroupItem } from '@signozhq/ui/toggle-group';
-import {
-	TooltipContent,
-	TooltipProvider,
-	TooltipRoot,
-	TooltipTrigger,
-} from '@signozhq/ui/tooltip';
-
-import { SpanDetailVariant } from './constants';
-
-interface DockOption {
-	value: SpanDetailVariant;
-	icon: ReactNode;
-	tooltip: string;
-}
-
-const DOCK_OPTIONS: DockOption[] = [
-	{
-		value: SpanDetailVariant.DIALOG,
-		icon: <Dock size={14} />,
-		tooltip: 'Open as floating panel',
-	},
-	{
-		value: SpanDetailVariant.DOCKED,
-		icon: <PanelBottom size={14} />,
-		tooltip: 'Dock at the bottom',
-	},
-	{
-		value: SpanDetailVariant.DOCKED_RIGHT,
-		icon: <PanelRight size={14} />,
-		tooltip: 'Dock on the right',
-	},
-];
-
-interface DockModeSwitcherProps {
-	value: SpanDetailVariant;
-	onChange: (value: SpanDetailVariant) => void;
-	tooltipClassName?: string;
-}
-
-function DockModeSwitcher({
-	value,
-	onChange,
-	tooltipClassName,
-}: DockModeSwitcherProps): JSX.Element {
-	return (
-		<TooltipProvider>
-			<ToggleGroup
-				type="single"
-				value={value}
-				onChange={(v): void => {
-					if (v) {
-						onChange(v as SpanDetailVariant);
-					}
-				}}
-				size="sm"
-			>
-				{DOCK_OPTIONS.map((option) => (
-					<TooltipRoot key={option.value}>
-						<TooltipTrigger asChild>
-							<span>
-								<ToggleGroupItem value={option.value}>{option.icon}</ToggleGroupItem>
-							</span>
-						</TooltipTrigger>
-						<TooltipContent className={tooltipClassName}>
-							{option.tooltip}
-						</TooltipContent>
-					</TooltipRoot>
-				))}
-			</ToggleGroup>
-		</TooltipProvider>
-	);
-}
-
-export default DockModeSwitcher;

frontend/src/pages/TraceDetailsV3/SpanDetailsPanel/SpanDetailsPanel.module.scss

@@ -3,10 +3,6 @@
 	display: flex;
 	flex-direction: column;
 	overflow: hidden;
-
-	:global(.details-header) {
-		height: 39px;
-	}
 }
 
 .body {

frontend/src/pages/TraceDetailsV3/SpanDetailsPanel/SpanDetailsPanel.tsx

@@ -1,16 +1,25 @@
 import { useCallback, useMemo } from 'react';
+import { Button } from '@signozhq/ui/button';
 import {
 	TabsContent,
 	TabsList,
 	TabsRoot,
 	TabsTrigger,
 } from '@signozhq/ui/tabs';
+import {
+	TooltipRoot,
+	TooltipContent,
+	TooltipProvider,
+	TooltipTrigger,
+} from '@signozhq/ui/tooltip';
 import {
 	Bookmark,
 	CalendarClock,
 	ChartColumnBig,
+	Dock,
 	Link2,
 	List,
+	PanelBottom,
 	ScrollText,
 	Timer,
 } from '@signozhq/icons';
@@ -52,7 +61,6 @@ import {
 	SpanDetailVariant,
 	VISIBLE_ACTIONS,
 } from './constants';
-import DockModeSwitcher from './DockModeSwitcher';
 import { useSpanAttributeActions } from './hooks/useSpanAttributeActions';
 import { useTracePinnedFields } from './hooks/useTracePinnedFields';
 import {
@@ -484,14 +492,31 @@ function SpanDetailsPanel({
 		];
 
 		if (onVariantChange) {
+			const isDocked = variant === SpanDetailVariant.DOCKED;
 			actions.push({
-				key: 'dock-mode',
+				key: 'dock-toggle',
 				component: (
-					<DockModeSwitcher
-						value={variant}
-						onChange={onVariantChange}
-						tooltipClassName={styles.dockToggleTooltip}
-					/>
+					<TooltipProvider>
+						<TooltipRoot>
+							<TooltipTrigger asChild>
+								<Button
+									variant="ghost"
+									size="icon"
+									color="secondary"
+									onClick={(): void =>
+										onVariantChange(
+											isDocked ? SpanDetailVariant.DIALOG : SpanDetailVariant.DOCKED,
+										)
+									}
+								>
+									{isDocked ? <Dock size={14} /> : <PanelBottom size={14} />}
+								</Button>
+							</TooltipTrigger>
+							<TooltipContent className={styles.dockToggleTooltip}>
+								{isDocked ? 'Open as floating panel' : 'Dock at the bottom'}
+							</TooltipContent>
+						</TooltipRoot>
+					</TooltipProvider>
 				),
 			});
 		}
@@ -528,10 +553,7 @@ function SpanDetailsPanel({
 		</>
 	);
 
-	if (
-		variant === SpanDetailVariant.DOCKED ||
-		variant === SpanDetailVariant.DOCKED_RIGHT
-	) {
+	if (variant === SpanDetailVariant.DOCKED) {
 		return <div className={styles.root}>{content}</div>;
 	}
 

frontend/src/pages/TraceDetailsV3/SpanDetailsPanel/constants.ts

@@ -22,7 +22,6 @@ export enum SpanDetailVariant {
 	DRAWER = 'drawer',
 	DIALOG = 'dialog',
 	DOCKED = 'docked',
-	DOCKED_RIGHT = 'right',
 }
 
 export const KEY_ATTRIBUTE_KEYS: Record<string, string[]> = {

frontend/src/pages/TraceDetailsV3/TraceDetailsV3.module.scss

@@ -4,28 +4,13 @@
 	flex-direction: column;
 }
 
-.layoutRow {
-	display: flex;
-	flex: 1;
-	min-height: 0;
-	overflow: hidden;
-}
-
 .content {
 	display: flex;
 	flex-direction: column;
 	flex: 1;
-	min-width: 0;
 	overflow: hidden;
 }
 
-.rightDock {
-	display: flex;
-	flex-direction: column;
-	border-left: 1px solid var(--l2-border);
-	min-width: 0;
-}
-
 // Shared Ant Collapse chrome reset for both the flamegraph and waterfall
 // collapse panels.
 .flameCollapse,

frontend/src/pages/TraceDetailsV3/TraceWaterfall/TraceWaterfallStates/Success/Success.tsx

@@ -893,7 +893,7 @@ function Success(props: ISuccessProps): JSX.Element {
 					/>
 					{/* Left panel - table with horizontal scroll */}
 					<ResizableBox
-						handle="right"
+						direction="horizontal"
 						defaultWidth={DEFAULT_SIDEBAR_WIDTH}
 						minWidth={MIN_SIDEBAR_WIDTH}
 						maxWidth={MAX_SIDEBAR_WIDTH}

frontend/src/pages/TraceDetailsV3/index.tsx

@@ -242,13 +242,9 @@ function TraceDetailsV3(): JSX.Element {
 		() =>
 			(getLocalStorageKey(
 				LOCALSTORAGE.TRACE_DETAILS_SPAN_DETAILS_POSITION,
-			) as SpanDetailVariant) || SpanDetailVariant.DOCKED_RIGHT,
+			) as SpanDetailVariant) || SpanDetailVariant.DIALOG,
 	);
 
-	const RIGHT_DOCK_MIN = 480;
-	const RIGHT_DOCK_MAX = 720;
-	const [rightDockWidth, setRightDockWidth] = useState(RIGHT_DOCK_MIN);
-
 	const handleVariantChange = useCallback(
 		(newVariant: SpanDetailVariant): void => {
 			setLocalStorageKey(
@@ -295,9 +291,7 @@ function TraceDetailsV3(): JSX.Element {
 		(!!errorFetchingTraceData || !traceData?.payload?.spans?.length);
 
 	const isDocked = spanDetailVariant === SpanDetailVariant.DOCKED;
-	const isRightDocked = spanDetailVariant === SpanDetailVariant.DOCKED_RIGHT;
 	const isWaterfallDocked = panelState.isOpen && isDocked;
-	const showRightDock = panelState.isOpen && isRightDocked;
 
 	const waterfallChildren = (
 		<ResizableBox
@@ -338,118 +332,94 @@ function TraceDetailsV3(): JSX.Element {
 					<NoData />
 				) : (
 					<>
-						<div className={styles.layoutRow}>
-							<div className={styles.content}>
-								<Collapse
-									// @ts-expect-error motion is passed through to rc-collapse to disable animation
-									motion={false}
-									activeKey={activeKeys.filter((k) => k === 'flame')}
-									onChange={(): void => handleCollapseChange('flame')}
-									size="small"
-									className={styles.flameCollapse}
-									items={[
-										{
-											key: 'flame',
-											label: (
-												<div className={styles.collapseLabel}>
-													<span className={styles.collapseTitle}>
-														Flame Graph
-														{traceData?.payload?.totalSpansCount &&
-															traceData.payload.totalSpansCount > FLAMEGRAPH_SPAN_LIMIT && (
-																<WarningPopover
-																	message="The total span count exceeds the visualization limit. Displaying a sampled subset of spans in flamegraph."
-																	placement="bottomLeft"
-																/>
-															)}
-													</span>
-													{traceData?.payload?.totalSpansCount ? (
-														<span className={styles.collapseCount}>
-															<span className={styles.collapseCountItem}>
-																<ChartNoAxesGantt size={13} />
-																Spans: {traceData.payload.totalSpansCount}
-															</span>
-															<span
-																className={cx(styles.collapseCountItem, {
-																	[styles.hasErrors]: traceData.payload.totalErrorSpansCount > 0,
-																})}
-															>
-																<TriangleAlert size={13} />
-																Errors: {traceData.payload.totalErrorSpansCount ?? 0}
-															</span>
+						<div className={styles.content}>
+							<Collapse
+								// @ts-expect-error motion is passed through to rc-collapse to disable animation
+								motion={false}
+								activeKey={activeKeys.filter((k) => k === 'flame')}
+								onChange={(): void => handleCollapseChange('flame')}
+								size="small"
+								className={styles.flameCollapse}
+								items={[
+									{
+										key: 'flame',
+										label: (
+											<div className={styles.collapseLabel}>
+												<span className={styles.collapseTitle}>
+													Flame Graph
+													{traceData?.payload?.totalSpansCount &&
+														traceData.payload.totalSpansCount > FLAMEGRAPH_SPAN_LIMIT && (
+															<WarningPopover
+																message="The total span count exceeds the visualization limit. Displaying a sampled subset of spans in flamegraph."
+																placement="bottomLeft"
+															/>
+														)}
+												</span>
+												{traceData?.payload?.totalSpansCount ? (
+													<span className={styles.collapseCount}>
+														<span className={styles.collapseCountItem}>
+															<ChartNoAxesGantt size={13} />
+															Spans: {traceData.payload.totalSpansCount}
 														</span>
-													) : null}
-												</div>
-											),
-											children: (
-												<ResizableBox defaultHeight={300} minHeight={100} maxHeight={400}>
-													<TraceFlamegraph
-														filteredSpanIds={filteredSpanIds}
-														isFilterActive={isFilterActive}
-														selectedSpan={selectedSpan}
-														totalSpansCount={totalSpansCount}
-													/>
-												</ResizableBox>
-											),
-										},
-									]}
-								/>
+														<span
+															className={cx(styles.collapseCountItem, {
+																[styles.hasErrors]: traceData.payload.totalErrorSpansCount > 0,
+															})}
+														>
+															<TriangleAlert size={13} />
+															Errors: {traceData.payload.totalErrorSpansCount ?? 0}
+														</span>
+													</span>
+												) : null}
+											</div>
+										),
+										children: (
+											<ResizableBox defaultHeight={300} minHeight={100} maxHeight={400}>
+												<TraceFlamegraph
+													filteredSpanIds={filteredSpanIds}
+													isFilterActive={isFilterActive}
+													selectedSpan={selectedSpan}
+													totalSpansCount={totalSpansCount}
+												/>
+											</ResizableBox>
+										),
+									},
+								]}
+							/>
 
-								<Collapse
-									// @ts-expect-error motion is passed through to rc-collapse to disable animation
-									motion={false}
-									activeKey={activeKeys.filter((k) => k === 'waterfall')}
-									onChange={(): void => handleCollapseChange('waterfall')}
-									size="small"
-									className={cx(styles.waterfallCollapse, {
-										[styles.isDocked]: isWaterfallDocked,
-									})}
-									items={[
-										{
-											key: 'waterfall',
-											label: 'Waterfall',
-											children: activeKeys.includes('waterfall')
-												? waterfallChildren
-												: null,
-										},
-									]}
-								/>
+							<Collapse
+								// @ts-expect-error motion is passed through to rc-collapse to disable animation
+								motion={false}
+								activeKey={activeKeys.filter((k) => k === 'waterfall')}
+								onChange={(): void => handleCollapseChange('waterfall')}
+								size="small"
+								className={cx(styles.waterfallCollapse, {
+									[styles.isDocked]: isWaterfallDocked,
+								})}
+								items={[
+									{
+										key: 'waterfall',
+										label: 'Waterfall',
+										children: activeKeys.includes('waterfall') ? waterfallChildren : null,
+									},
+								]}
+							/>
 
-								{panelState.isOpen && isDocked && (
-									<div className={styles.dockedSpanDetails}>
-										<SpanDetailsPanel
-											panelState={panelState}
-											selectedSpan={selectedSpan}
-											variant={SpanDetailVariant.DOCKED}
-											onVariantChange={handleVariantChange}
-											traceStartTime={traceData?.payload?.startTimestampMillis}
-											traceEndTime={traceData?.payload?.endTimestampMillis}
-										/>
-									</div>
-								)}
-							</div>
-
-							{showRightDock && (
-								<ResizableBox
-									handle="left"
-									defaultWidth={rightDockWidth}
-									minWidth={RIGHT_DOCK_MIN}
-									maxWidth={RIGHT_DOCK_MAX}
-									onResize={setRightDockWidth}
-									className={styles.rightDock}
-								>
+							{panelState.isOpen && isDocked && (
+								<div className={styles.dockedSpanDetails}>
 									<SpanDetailsPanel
 										panelState={panelState}
 										selectedSpan={selectedSpan}
-										variant={SpanDetailVariant.DOCKED_RIGHT}
+										variant={SpanDetailVariant.DOCKED}
 										onVariantChange={handleVariantChange}
 										traceStartTime={traceData?.payload?.startTimestampMillis}
 										traceEndTime={traceData?.payload?.endTimestampMillis}
 									/>
-								</ResizableBox>
+								</div>
 							)}
 						</div>
 
-						{panelState.isOpen && spanDetailVariant === SpanDetailVariant.DIALOG && (
+						{panelState.isOpen && !isDocked && (
 							<SpanDetailsPanel
 								panelState={panelState}
 								selectedSpan={selectedSpan}

frontend/src/periscope/components/ResizableBox/ResizableBox.styles.scss

@@ -23,36 +23,20 @@
 			background: var(--primary);
 		}
 
-		&--top,
-		&--bottom {
+		&--vertical {
+			bottom: 0;
 			left: 0;
 			right: 0;
 			height: 1px;
 			cursor: row-resize;
 		}
 
-		&--left,
-		&--right {
+		&--horizontal {
+			right: 0;
 			top: 0;
 			bottom: 0;
 			width: 1px;
 			cursor: col-resize;
 		}
-
-		&--top {
-			top: 0;
-		}
-
-		&--bottom {
-			bottom: 0;
-		}
-
-		&--left {
-			left: 0;
-		}
-
-		&--right {
-			right: 0;
-		}
 	}
 }

frontend/src/periscope/components/ResizableBox/ResizableBox.tsx

@@ -2,15 +2,9 @@ import { useCallback, useRef, useState } from 'react';
 
 import './ResizableBox.styles.scss';
 
-export type ResizableBoxHandle = 'top' | 'right' | 'bottom' | 'left';
-
 export interface ResizableBoxProps {
 	children: React.ReactNode;
-	// Which edge the resize handle sits on. The edge determines the axis:
-	// 'top'/'bottom' → vertical resize (height), 'left'/'right' → horizontal
-	// resize (width). Dragging the handle away from the content grows the box;
-	// dragging it toward the content shrinks it.
-	handle?: ResizableBoxHandle;
+	direction?: 'vertical' | 'horizontal';
 	defaultHeight?: number;
 	minHeight?: number;
 	maxHeight?: number;
@@ -24,7 +18,7 @@ export interface ResizableBoxProps {
 
 function ResizableBox({
 	children,
-	handle = 'bottom',
+	direction = 'vertical',
 	defaultHeight = 200,
 	minHeight = 50,
 	maxHeight = Infinity,
@@ -35,8 +29,7 @@ function ResizableBox({
 	disabled = false,
 	className,
 }: ResizableBoxProps): JSX.Element {
-	const isHorizontal = handle === 'left' || handle === 'right';
-	const isStartHandle = handle === 'top' || handle === 'left';
+	const isHorizontal = direction === 'horizontal';
 	const [size, setSize] = useState(isHorizontal ? defaultWidth : defaultHeight);
 	const containerRef = useRef<HTMLDivElement>(null);
 
@@ -47,13 +40,10 @@ function ResizableBox({
 			const startSize = size;
 			const min = isHorizontal ? minWidth : minHeight;
 			const max = isHorizontal ? maxWidth : maxHeight;
-			// Start-edge handle: pointer moving away from content (negative delta)
-			// grows the box, so invert the sign.
-			const deltaSign = isStartHandle ? -1 : 1;
 
 			const onMouseMove = (moveEvent: MouseEvent): void => {
 				const currentPos = isHorizontal ? moveEvent.clientX : moveEvent.clientY;
-				const delta = (currentPos - startPos) * deltaSign;
+				const delta = currentPos - startPos;
 				const newSize = Math.min(max, Math.max(min, startSize + delta));
 				setSize(newSize);
 				onResize?.(newSize);
@@ -71,16 +61,7 @@ function ResizableBox({
 			document.addEventListener('mousemove', onMouseMove);
 			document.addEventListener('mouseup', onMouseUp);
 		},
-		[
-			size,
-			isHorizontal,
-			isStartHandle,
-			minWidth,
-			maxWidth,
-			minHeight,
-			maxHeight,
-			onResize,
-		],
+		[size, isHorizontal, minWidth, maxWidth, minHeight, maxHeight, onResize],
 	);
 
 	const containerStyle = disabled
@@ -88,7 +69,7 @@ function ResizableBox({
 		: isHorizontal
 			? { width: size }
 			: { height: size };
-	const handleClass = `resizable-box__handle resizable-box__handle--${handle}`;
+	const handleClass = `resizable-box__handle resizable-box__handle--${direction}`;
 
 	return (
 		<div

pkg/alertmanager/alertmanagernotify/email/email.go

@@ -23,13 +23,7 @@ import (
 	"sync"
 	"time"
 
-	htmltemplate "html/template"
-
-	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer"
-	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
-	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	commoncfg "github.com/prometheus/common/config"
 
 	"github.com/prometheus/alertmanager/config"
@@ -40,39 +34,20 @@ import (
 
 const (
 	Integration = "email"
-
-	// alertEmailLayoutTemplate is the name of the HTML layout template that
-	// wraps the rendered alert bodies. It is loaded into the notification
-	// template (n.tmpl) from the alertmanager templates config and lives at
-	// templates/alertmanager/email.gotmpl.
-	alertEmailLayoutTemplate = "email.signoz.html"
 )
 
 // Email implements a Notifier for email notifications.
 type Email struct {
-	conf      *config.EmailConfig
-	tmpl      *template.Template
-	logger    *slog.Logger
-	hostname  string
-	templater alertmanagertypes.Templater
-}
-
-// layoutData is the value passed to the email.signoz.html layout
-// template. It embeds NotificationTemplateData so templates can reference
-// `.Alert.Status`, `.Alert.TotalFiring`, `.Alert.TotalResolved`,
-// `.NotificationTemplateData.ExternalURL`, etc. alongside the rendered
-// Title and per-alert Bodies.
-type layoutData struct {
-	alertmanagertypes.NotificationTemplateData
-	Title  string
-	Bodies []htmltemplate.HTML
+	conf     *config.EmailConfig
+	tmpl     *template.Template
+	logger   *slog.Logger
+	hostname string
 }
 
 var errNoAuthUsernameConfigured = errors.NewInternalf(errors.CodeInternal, "no auth username configured")
 
-// New returns a new Email notifier. When the email.signoz.html layout is
-// not defined in t, custom-body alerts fall back to plain <div>-wrapped HTML.
-func New(c *config.EmailConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater) *Email {
+// New returns a new Email notifier.
+func New(c *config.EmailConfig, t *template.Template, l *slog.Logger) *Email {
 	if _, ok := c.Headers["Subject"]; !ok {
 		c.Headers["Subject"] = config.DefaultEmailSubject
 	}
@@ -88,7 +63,7 @@ func New(c *config.EmailConfig, t *template.Template, l *slog.Logger, templater
 	if err != nil {
 		h = "localhost.localdomain"
 	}
-	return &Email{conf: c, tmpl: t, logger: l, hostname: h, templater: templater}
+	return &Email{conf: c, tmpl: t, logger: l, hostname: h}
 }
 
 // auth resolves a string of authentication mechanisms.
@@ -224,9 +199,9 @@ func (n *Email) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
 
 	if ok, mech := c.Extension("AUTH"); ok {
 		auth, err := n.auth(mech)
-		if err != nil && !errors.Is(err, errNoAuthUsernameConfigured) {
+		if err != nil && err != errNoAuthUsernameConfigured {
 			return true, errors.WrapInternalf(err, errors.CodeInternal, "find auth mechanism")
-		} else if errors.Is(err, errNoAuthUsernameConfigured) {
+		} else if err == errNoAuthUsernameConfigured {
 			n.logger.DebugContext(ctx, "no auth username configured. Attempting to send email without authenticating")
 		}
 		if auth != nil {
@@ -270,16 +245,6 @@ func (n *Email) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
 		}
 	}
 
-	// Prepare the content for the email. subject, when non-empty, overrides
-	// the configured Subject header for this notification only. We deliberately
-	// do not mutate n.conf.Headers here: the config map is shared across
-	// concurrent notifications to the same receiver.
-	subject, htmlBody, err := n.prepareContent(ctx, as)
-	if err != nil {
-		n.logger.ErrorContext(ctx, "failed to prepare notification content", errors.Attr(err))
-		return false, err
-	}
-
 	// Send the email headers and body.
 	message, err := c.Data()
 	if err != nil {
@@ -297,10 +262,6 @@ func (n *Email) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
 
 	buffer := &bytes.Buffer{}
 	for header, t := range n.conf.Headers {
-		if header == "Subject" {
-			fmt.Fprintf(buffer, "%s: %s\r\n", header, mime.QEncoding.Encode("utf-8", subject))
-			continue
-		}
 		value, err := n.tmpl.ExecuteTextString(t, data)
 		if err != nil {
 			return false, errors.WrapInternalf(err, errors.CodeInternal, "execute %q header template", header)
@@ -375,7 +336,7 @@ func (n *Email) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
 		}
 	}
 
-	if htmlBody != "" {
+	if len(n.conf.HTML) > 0 {
 		// Html template
 		// Preferred alternative placed last per section 5.1.4 of RFC 2046
 		// https://www.ietf.org/rfc/rfc2046.txt
@@ -386,8 +347,12 @@ func (n *Email) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
 		if err != nil {
 			return false, errors.WrapInternalf(err, errors.CodeInternal, "create part for html template")
 		}
+		body, err := n.tmpl.ExecuteHTMLString(n.conf.HTML, data)
+		if err != nil {
+			return false, errors.WrapInternalf(err, errors.CodeInternal, "execute html template")
+		}
 		qw := quotedprintable.NewWriter(w)
-		_, err = qw.Write([]byte(htmlBody))
+		_, err = qw.Write([]byte(body))
 		if err != nil {
 			return true, errors.WrapInternalf(err, errors.CodeInternal, "write HTML part")
 		}
@@ -416,124 +381,6 @@ func (n *Email) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
 	return false, nil
 }
 
-// prepareContent returns a subject override (empty when the default config
-// Subject should be used) and the HTML body for the email. Callers must treat
-// the subject as local state and never write it back to n.conf.Headers.
-func (n *Email) prepareContent(ctx context.Context, alerts []*types.Alert) (string, string, error) {
-	customTitle, customBody := alertmanagertemplate.ExtractTemplatesFromAnnotations(alerts)
-	result, err := n.templater.Expand(ctx, alertmanagertypes.ExpandRequest{
-		TitleTemplate:        customTitle,
-		BodyTemplate:         customBody,
-		DefaultTitleTemplate: n.conf.Headers["Subject"],
-		DefaultBodyTemplate:  n.conf.HTML,
-	}, alerts)
-	if err != nil {
-		return "", "", err
-	}
-
-	subject := result.Title
-
-	if !result.IsDefaultBody {
-		// Custom-body path: render each expanded markdown body to HTML, then
-		// wrap the whole thing in the email.signoz.html layout (or fall
-		// back to plain <div> wrapping when the layout template is not loaded).
-		for i, body := range result.Body {
-			if body == "" {
-				continue
-			}
-			rendered, err := markdownrenderer.RenderHTML(body)
-			if err != nil {
-				return "", "", err
-			}
-			result.Body[i] = rendered
-		}
-		appendRelatedLinkButtons(alerts, result.Body)
-		html, err := n.renderLayout(result)
-		if err != nil {
-			n.logger.WarnContext(ctx, "custom email template rendering failed, falling back to plain <div> wrap", errors.Attr(err))
-			return subject, wrapBodiesAsDivs(result.Body), nil
-		}
-		return subject, html, nil
-	}
-
-	return subject, result.Body[0], nil
-}
-
-// renderLayout wraps result in the email.signoz.html HTML layout loaded
-// into n.tmpl from the alertmanager templates config. Returns an error when the
-// layout template is not defined (e.g. in tests where no templates are loaded)
-// so prepareContent can fall back to plain <div> wrapping.
-func (n *Email) renderLayout(result *alertmanagertypes.ExpandResult) (string, error) {
-	bodies := make([]htmltemplate.HTML, 0, len(result.Body))
-	for _, b := range result.Body {
-		bodies = append(bodies, htmltemplate.HTML(b))
-	}
-	data := layoutData{Title: result.Title, Bodies: bodies}
-	if result.NotificationData != nil {
-		data.NotificationTemplateData = *result.NotificationData
-	}
-	html, err := n.tmpl.ExecuteHTMLString(`{{ template "`+alertEmailLayoutTemplate+`" . }}`, data)
-	if err != nil {
-		return "", errors.WrapInternalf(err, errors.CodeInternal, "failed to render email layout")
-	}
-	return html, nil
-}
-
-// appendRelatedLinkButtons appends "View Related Logs/Traces" buttons to each
-// per-alert body when the rule manager attached the corresponding annotation.
-// bodies is positionally aligned with alerts (see alertmanagertemplate.Prepare);
-// empty bodies are skipped so we never attach a button to an alert that produced
-// no visible content.
-func appendRelatedLinkButtons(alerts []*types.Alert, bodies []string) {
-	for i := range bodies {
-		if i >= len(alerts) || bodies[i] == "" {
-			continue
-		}
-		if link := alerts[i].Annotations[ruletypes.AnnotationRelatedLogs]; link != "" {
-			bodies[i] += htmlButton("View Related Logs", string(link))
-		}
-		if link := alerts[i].Annotations[ruletypes.AnnotationRelatedTraces]; link != "" {
-			bodies[i] += htmlButton("View Related Traces", string(link))
-		}
-	}
-}
-
-func wrapBodiesAsDivs(bodies []string) string {
-	var b strings.Builder
-	for _, part := range bodies {
-		if part == "" {
-			continue
-		}
-		b.WriteString("<div>")
-		b.WriteString(part)
-		b.WriteString("</div>")
-	}
-	return b.String()
-}
-
-func htmlButton(text, url string) string {
-	return fmt.Sprintf(`
-	<a href="%s" target="_blank" style="text-decoration: none;">
-<button style="
-    padding: 6px 16px;
-    /* Default System Font */
-    font-family: sans-serif;
-    font-size: 14px;
-    font-weight: 500;
-    line-height: 1.5;
-    /* Light Theme & Dynamic Background (Solid) */
-    color: #111827;
-    background-color: #f9fafb;
-    /* Static Outline */
-    border: 1px solid #d1d5db;
-    border-radius: 4px;
-    cursor: pointer;
-">
-  %s
-</button>
-</a>`, url, text)
-}
-
 type loginAuth struct {
 	username, password string
 }

pkg/alertmanager/alertmanagernotify/email/email_test.go

@@ -8,7 +8,6 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"log/slog"
 	"net"
 	"net/http"
 	"net/url"
@@ -18,10 +17,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
-	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/emersion/go-smtp"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
@@ -46,11 +42,6 @@ const (
 	emailFrom = "alertmanager@example.com"
 )
 
-// testTemplater returns a Templater bound to tmpl with a discard logger.
-func testTemplater(tmpl *template.Template) alertmanagertypes.Templater {
-	return alertmanagertemplate.New(tmpl, slog.New(slog.DiscardHandler))
-}
-
 // email represents an email returned by the MailDev REST API.
 // See https://github.com/djfarrelly/MailDev/blob/master/docs/rest.md.
 type email struct {
@@ -171,7 +162,7 @@ func notifyEmailWithContext(ctx context.Context, t *testing.T, cfg *config.Email
 		return nil, false, err
 	}
 
-	email := New(cfg, tmpl, promslog.NewNopLogger(), testTemplater(tmpl))
+	email := New(cfg, tmpl, promslog.NewNopLogger())
 
 	retry, err := email.Notify(ctx, firingAlert)
 	if err != nil {
@@ -715,7 +706,7 @@ func TestEmailRejected(t *testing.T) {
 	tmpl, firingAlert, err := prepare(cfg)
 	require.NoError(t, err)
 
-	e := New(cfg, tmpl, promslog.NewNopLogger(), testTemplater(tmpl))
+	e := New(cfg, tmpl, promslog.NewNopLogger())
 
 	// Send the alert to mock SMTP server.
 	retry, err := e.Notify(context.Background(), firingAlert)
@@ -1039,135 +1030,6 @@ func TestEmailImplicitTLS(t *testing.T) {
 	}
 }
 
-func TestPrepareContent(t *testing.T) {
-	t.Run("default title template; custom body template", func(t *testing.T) {
-		tmpl, err := template.FromGlobs([]string{})
-		require.NoError(t, err)
-		tmpl.ExternalURL, _ = url.Parse("http://am")
-
-		bodyTpl := "line $labels.instance"
-		a1 := &types.Alert{
-			Alert: model.Alert{
-				Labels: model.LabelSet{
-					model.LabelName("instance"): model.LabelValue("one"),
-				},
-				Annotations: model.LabelSet{
-					model.LabelName(ruletypes.AnnotationBodyTemplate): model.LabelValue(bodyTpl),
-				},
-			},
-		}
-		a2 := &types.Alert{
-			Alert: model.Alert{
-				Labels: model.LabelSet{
-					model.LabelName("instance"): model.LabelValue("two"),
-				},
-				Annotations: model.LabelSet{
-					model.LabelName(ruletypes.AnnotationBodyTemplate): model.LabelValue(bodyTpl),
-				},
-			},
-		}
-		alerts := []*types.Alert{a1, a2}
-
-		cfg := &config.EmailConfig{Headers: map[string]string{"Subject": "subj"}}
-		n := New(cfg, tmpl, promslog.NewNopLogger(), testTemplater(tmpl))
-
-		ctx := context.Background()
-		subject, htmlBody, err := n.prepareContent(ctx, alerts)
-		require.NoError(t, err)
-		require.Equal(t, "subj", subject)
-		require.Equal(t, "<div><p>line one</p>\n</div><div><p>line two</p>\n</div>", htmlBody)
-	})
-
-	t.Run("custom title template; default body HTML template", func(t *testing.T) {
-		tmpl, err := template.FromGlobs([]string{})
-		require.NoError(t, err)
-		tmpl.ExternalURL, _ = url.Parse("http://am")
-
-		firingAlert := &types.Alert{
-			Alert: model.Alert{
-				Labels: model.LabelSet{},
-				Annotations: model.LabelSet{
-					model.LabelName(ruletypes.AnnotationTitleTemplate): model.LabelValue("fixed from $alert.status"),
-				},
-				StartsAt: time.Now(),
-				EndsAt:   time.Now().Add(time.Hour),
-			},
-		}
-		alerts := []*types.Alert{firingAlert}
-		cfg := &config.EmailConfig{
-			Headers: map[string]string{},
-			HTML:    "Status: {{ .Status }}",
-		}
-		n := New(cfg, tmpl, promslog.NewNopLogger(), testTemplater(tmpl))
-
-		ctx := context.Background()
-		subject, htmlBody, err := n.prepareContent(ctx, alerts)
-		require.NoError(t, err)
-		require.Equal(t, "Status: firing", htmlBody)
-		require.Equal(t, "fixed from firing", subject)
-	})
-
-	t.Run("default template without HTML", func(t *testing.T) {
-		cfg := &config.EmailConfig{Headers: map[string]string{"Subject": "the email subject"}}
-		tmpl, err := template.FromGlobs([]string{})
-		require.NoError(t, err)
-		tmpl.ExternalURL, _ = url.Parse("http://am")
-		n := New(cfg, tmpl, promslog.NewNopLogger(), testTemplater(tmpl))
-
-		firingAlert := &types.Alert{
-			Alert: model.Alert{
-				Labels:   model.LabelSet{},
-				StartsAt: time.Now(),
-				EndsAt:   time.Now().Add(time.Hour),
-			},
-		}
-		alerts := []*types.Alert{firingAlert}
-		ctx := context.Background()
-		subject, htmlBody, err := n.prepareContent(ctx, alerts)
-		require.NoError(t, err)
-		require.Equal(t, "", htmlBody)
-		require.Equal(t, "the email subject", subject)
-	})
-
-	t.Run("custom title template; custom body template", func(t *testing.T) {
-		// Load the email.signoz.html layout into the notification template
-		// the same way the alertmanager server does via the templates config.
-		tmpl, err := template.FromGlobs([]string{"../../../../templates/alertmanager/*.gotmpl"})
-		require.NoError(t, err)
-		tmpl.ExternalURL, _ = url.Parse("http://am")
-
-		firingAlert := &types.Alert{
-			Alert: model.Alert{
-				Labels: model.LabelSet{
-					model.LabelName("instance"): model.LabelValue("two"),
-				},
-				Annotations: model.LabelSet{
-					model.LabelName(ruletypes.AnnotationTitleTemplate): model.LabelValue("fixed from $alert.status"),
-					model.LabelName(ruletypes.AnnotationBodyTemplate):  model.LabelValue("line $labels.instance"),
-				},
-				StartsAt: time.Now(),
-				EndsAt:   time.Now().Add(time.Hour),
-			},
-		}
-		alerts := []*types.Alert{firingAlert}
-		cfg := &config.EmailConfig{
-			Headers: map[string]string{"Subject": "subject"},
-			HTML:    "Well, what are you?",
-		}
-
-		n := New(cfg, tmpl, promslog.NewNopLogger(), testTemplater(tmpl))
-
-		ctx := context.Background()
-		subject, htmlBody, err := n.prepareContent(ctx, alerts)
-		require.NoError(t, err)
-		require.Contains(t, htmlBody, "<!DOCTYPE html>")
-		require.Contains(t, htmlBody, "<p>line two</p>")
-		require.NotContains(t, htmlBody, "Well, what are you?")
-		require.Equal(t, subject, "fixed from firing")
-		require.NotContains(t, subject, "subject")
-	})
-}
-
 func ptrTo(b bool) *bool {
 	return &b
 }

pkg/alertmanager/alertmanagernotify/msteamsv2/msteamsv2.go

@@ -15,9 +15,7 @@ import (
 	"slices"
 	"strings"
 
-	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
 
@@ -46,7 +44,6 @@ type Notifier struct {
 	retrier      *notify.Retrier
 	webhookURL   *config.SecretURL
 	postJSONFunc func(ctx context.Context, client *http.Client, url string, body io.Reader) (*http.Response, error)
-	templater    alertmanagertypes.Templater
 }
 
 // https://learn.microsoft.com/en-us/connectors/teams/?tabs=text1#adaptivecarditemschema
@@ -55,7 +52,7 @@ type Content struct {
 	Type    string   `json:"type"`
 	Version string   `json:"version"`
 	Body    []Body   `json:"body"`
-	Msteams Msteams  `json:"msteams,omitzero"`
+	Msteams Msteams  `json:"msteams,omitempty"`
 	Actions []Action `json:"actions"`
 }
 
@@ -97,7 +94,7 @@ type teamsMessage struct {
 }
 
 // New returns a new notifier that uses the Microsoft Teams Power Platform connector.
-func New(c *config.MSTeamsV2Config, t *template.Template, titleLink string, l *slog.Logger, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+func New(c *config.MSTeamsV2Config, t *template.Template, titleLink string, l *slog.Logger, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
 	client, err := notify.NewClientWithTracing(*c.HTTPConfig, Integration, httpOpts...)
 	if err != nil {
 		return nil, err
@@ -112,7 +109,6 @@ func New(c *config.MSTeamsV2Config, t *template.Template, titleLink string, l *s
 		retrier:      &notify.Retrier{},
 		webhookURL:   c.WebhookURL,
 		postJSONFunc: notify.PostJSON,
-		templater:    templater,
 	}
 
 	return n, nil
@@ -132,11 +128,25 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 		return false, err
 	}
 
+	title := tmpl(n.conf.Title)
+	if err != nil {
+		return false, err
+	}
+
 	titleLink := tmpl(n.titleLink)
 	if err != nil {
 		return false, err
 	}
 
+	alerts := types.Alerts(as...)
+	color := colorGrey
+	switch alerts.Status() {
+	case model.AlertFiring:
+		color = colorRed
+	case model.AlertResolved:
+		color = colorGreen
+	}
+
 	var url string
 	if n.conf.WebhookURL != nil {
 		url = n.conf.WebhookURL.String()
@@ -148,12 +158,6 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 		url = strings.TrimSpace(string(content))
 	}
 
-	bodyBlocks, err := n.prepareContent(ctx, as)
-	if err != nil {
-		n.logger.ErrorContext(ctx, "failed to prepare notification content", errors.Attr(err))
-		return false, err
-	}
-
 	// A message as referenced in https://learn.microsoft.com/en-us/connectors/teams/?tabs=text1%2Cdotnet#request-body-schema
 	t := teamsMessage{
 		Type: "message",
@@ -165,7 +169,17 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 					Schema:  "http://adaptivecards.io/schemas/adaptive-card.json",
 					Type:    "AdaptiveCard",
 					Version: "1.2",
-					Body:    bodyBlocks,
+					Body: []Body{
+						{
+							Type:   "TextBlock",
+							Text:   title,
+							Weight: "Bolder",
+							Size:   "Medium",
+							Wrap:   true,
+							Style:  "heading",
+							Color:  color,
+						},
+					},
 					Actions: []Action{
 						{
 							Type:  "Action.OpenUrl",
@@ -181,6 +195,20 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 		},
 	}
 
+	// add labels and annotations to the body of all alerts
+	for _, alert := range as {
+		t.Attachments[0].Content.Body = append(t.Attachments[0].Content.Body, Body{
+			Type:   "TextBlock",
+			Text:   "Alerts",
+			Weight: "Bolder",
+			Size:   "Medium",
+			Wrap:   true,
+			Color:  color,
+		})
+
+		t.Attachments[0].Content.Body = append(t.Attachments[0].Content.Body, n.createLabelsAndAnnotationsBody(alert)...)
+	}
+
 	var payload bytes.Buffer
 	if err = json.NewEncoder(&payload).Encode(t); err != nil {
 		return false, err
@@ -200,75 +228,6 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 	return shouldRetry, err
 }
 
-// prepareContent builds the Adaptive Card body blocks for the notification.
-// The first block is always the title; the remainder depends on whether the
-// alerts carried a custom body template.
-func (n *Notifier) prepareContent(ctx context.Context, alerts []*types.Alert) ([]Body, error) {
-	customTitle, customBody := alertmanagertemplate.ExtractTemplatesFromAnnotations(alerts)
-	result, err := n.templater.Expand(ctx, alertmanagertypes.ExpandRequest{
-		TitleTemplate:        customTitle,
-		BodyTemplate:         customBody,
-		DefaultTitleTemplate: n.conf.Title,
-		DefaultBodyTemplate:  n.conf.Text,
-	}, alerts)
-	if err != nil {
-		return nil, err
-	}
-
-	color := colorGrey
-	switch types.Alerts(alerts...).Status() {
-	case model.AlertFiring:
-		color = colorRed
-	case model.AlertResolved:
-		color = colorGreen
-	}
-
-	blocks := []Body{{
-		Type:   "TextBlock",
-		Text:   result.Title,
-		Weight: "Bolder",
-		Size:   "Medium",
-		Wrap:   true,
-		Style:  "heading",
-		Color:  color,
-	}}
-
-	if result.IsDefaultBody {
-		for _, alert := range alerts {
-			blocks = append(blocks, Body{
-				Type:   "TextBlock",
-				Text:   "Alerts",
-				Weight: "Bolder",
-				Size:   "Medium",
-				Wrap:   true,
-				Color:  color,
-			})
-			blocks = append(blocks, n.createLabelsAndAnnotationsBody(alert)...)
-		}
-		return blocks, nil
-	}
-
-	// Custom body path: result.Body is positionally aligned with alerts;
-	// entries for alerts whose template rendered empty are kept as "" so we
-	// can skip them here without shifting the per-alert color index.
-	for i, body := range result.Body {
-		if body == "" || i >= len(alerts) {
-			continue
-		}
-		perAlertColor := colorRed
-		if alerts[i].Resolved() {
-			perAlertColor = colorGreen
-		}
-		blocks = append(blocks, Body{
-			Type:  "TextBlock",
-			Text:  body,
-			Wrap:  true,
-			Color: perAlertColor,
-		})
-	}
-	return blocks, nil
-}
-
 func (*Notifier) createLabelsAndAnnotationsBody(alert *types.Alert) []Body {
 	bodies := []Body{}
 	bodies = append(bodies, Body{
@@ -299,8 +258,7 @@ func (*Notifier) createLabelsAndAnnotationsBody(alert *types.Alert) []Body {
 
 	annotationsFacts := []Fact{}
 	for k, v := range alert.Annotations {
-		if slices.Contains([]string{"summary", "related_logs", "related_traces"}, string(k)) ||
-			alertmanagertypes.IsPrivateAnnotation(string(k)) {
+		if slices.Contains([]string{"summary", "related_logs", "related_traces"}, string(k)) {
 			continue
 		}
 		annotationsFacts = append(annotationsFacts, Fact{Title: string(k), Value: string(v)})

pkg/alertmanager/alertmanagernotify/msteamsv2/msteamsv2_test.go

@@ -8,7 +8,6 @@ import (
 	"context"
 	"encoding/json"
 	"io"
-	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
@@ -16,9 +15,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
-	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
-	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/common/promslog"
@@ -27,28 +23,21 @@ import (
 	test "github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/alertmanagernotifytest"
 	"github.com/prometheus/alertmanager/config"
 	"github.com/prometheus/alertmanager/notify"
-	"github.com/prometheus/alertmanager/template"
 	"github.com/prometheus/alertmanager/types"
 )
 
-func newTestTemplater(tmpl *template.Template) alertmanagertypes.Templater {
-	return alertmanagertemplate.New(tmpl, slog.New(slog.DiscardHandler))
-}
-
 // This is a test URL that has been modified to not be valid.
 var testWebhookURL, _ = url.Parse("https://example.westeurope.logic.azure.com:443/workflows/xxx/triggers/manual/paths/invoke?api-version=2016-06-01&sp=%2Ftriggers%2Fmanual%2Frun&sv=1.0&sig=xxx")
 
 func TestMSTeamsV2Retry(t *testing.T) {
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.MSTeamsV2Config{
 			WebhookURL: &config.SecretURL{URL: testWebhookURL},
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		`{{ template "msteamsv2.default.titleLink" . }}`,
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -75,16 +64,14 @@ func TestNotifier_Notify_WithReason(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			tmpl := test.CreateTmpl(t)
 			notifier, err := New(
 				&config.MSTeamsV2Config{
 					WebhookURL: &config.SecretURL{URL: testWebhookURL},
 					HTTPConfig: &commoncfg.HTTPClientConfig{},
 				},
-				tmpl,
+				test.CreateTmpl(t),
 				`{{ template "msteamsv2.default.titleLink" . }}`,
 				promslog.NewNopLogger(),
-				newTestTemplater(tmpl),
 			)
 			require.NoError(t, err)
 
@@ -166,8 +153,7 @@ func TestMSTeamsV2Templating(t *testing.T) {
 		t.Run(tc.title, func(t *testing.T) {
 			tc.cfg.WebhookURL = &config.SecretURL{URL: u}
 			tc.cfg.HTTPConfig = &commoncfg.HTTPClientConfig{}
-			tmpl := test.CreateTmpl(t)
-			pd, err := New(tc.cfg, tmpl, tc.titleLink, promslog.NewNopLogger(), newTestTemplater(tmpl))
+			pd, err := New(tc.cfg, test.CreateTmpl(t), tc.titleLink, promslog.NewNopLogger())
 			require.NoError(t, err)
 
 			ctx := context.Background()
@@ -200,124 +186,20 @@ func TestMSTeamsV2RedactedURL(t *testing.T) {
 	defer fn()
 
 	secret := "secret"
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.MSTeamsV2Config{
 			WebhookURL: &config.SecretURL{URL: u},
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		`{{ template "msteamsv2.default.titleLink" . }}`,
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
 	test.AssertNotifyLeaksNoSecret(ctx, t, notifier, secret)
 }
 
-func TestPrepareContent(t *testing.T) {
-	t.Run("default template - firing alerts", func(t *testing.T) {
-		tmpl := test.CreateTmpl(t)
-		notifier, err := New(
-			&config.MSTeamsV2Config{
-				WebhookURL: &config.SecretURL{URL: testWebhookURL},
-				HTTPConfig: &commoncfg.HTTPClientConfig{},
-				Title:      "Alertname: {{ .CommonLabels.alertname }}",
-			},
-			tmpl,
-			`{{ template "msteamsv2.default.titleLink" . }}`,
-			promslog.NewNopLogger(),
-			newTestTemplater(tmpl),
-		)
-		require.NoError(t, err)
-
-		ctx := context.Background()
-		ctx = notify.WithGroupKey(ctx, "1")
-
-		alerts := []*types.Alert{
-			{
-				Alert: model.Alert{
-					Labels: model.LabelSet{"alertname": "test"},
-					// Custom body template
-					Annotations: model.LabelSet{
-						ruletypes.AnnotationBodyTemplate: "Firing alert: $alertname",
-					},
-					StartsAt: time.Now(),
-					EndsAt:   time.Now().Add(time.Hour),
-				},
-			},
-		}
-		blocks, err := notifier.prepareContent(ctx, alerts)
-		require.NoError(t, err)
-		require.NotEmpty(t, blocks)
-		// First block should be the title with color (firing = red)
-		require.Equal(t, "Bolder", blocks[0].Weight)
-		require.Equal(t, colorRed, blocks[0].Color)
-		// verify title text
-		require.Equal(t, "Alertname: test", blocks[0].Text)
-		// verify body text
-		require.Equal(t, "Firing alert: test", blocks[1].Text)
-	})
-
-	t.Run("custom template - per-alert color", func(t *testing.T) {
-		tmpl := test.CreateTmpl(t)
-		notifier, err := New(
-			&config.MSTeamsV2Config{
-				WebhookURL: &config.SecretURL{URL: testWebhookURL},
-				HTTPConfig: &commoncfg.HTTPClientConfig{},
-			},
-			tmpl,
-			`{{ template "msteamsv2.default.titleLink" . }}`,
-			promslog.NewNopLogger(),
-			newTestTemplater(tmpl),
-		)
-		require.NoError(t, err)
-
-		ctx := context.Background()
-		ctx = notify.WithGroupKey(ctx, "1")
-
-		alerts := []*types.Alert{
-			{
-				Alert: model.Alert{
-					Labels: model.LabelSet{"alertname": "test1"},
-					Annotations: model.LabelSet{
-						"summary":                         "test",
-						ruletypes.AnnotationTitleTemplate: "Custom Title",
-						ruletypes.AnnotationBodyTemplate:  "custom body $alertname",
-					},
-					StartsAt: time.Now(),
-					EndsAt:   time.Now().Add(time.Hour),
-				},
-			},
-			{
-				Alert: model.Alert{
-					Labels: model.LabelSet{"alertname": "test2"},
-					Annotations: model.LabelSet{
-						"summary":                         "test",
-						ruletypes.AnnotationTitleTemplate: "Custom Title",
-						ruletypes.AnnotationBodyTemplate:  "custom body $alertname",
-					},
-					StartsAt: time.Now().Add(-time.Hour),
-					EndsAt:   time.Now().Add(-time.Minute),
-				},
-			},
-		}
-		blocks, err := notifier.prepareContent(ctx, alerts)
-		require.NoError(t, err)
-		require.NotEmpty(t, blocks)
-		// total 3 blocks: title and 2 body blocks
-		require.True(t, len(blocks) == 3)
-		// First block: title color is overall color of the alerts
-		require.Equal(t, colorRed, blocks[0].Color)
-		// verify title text
-		require.Equal(t, "Custom Title", blocks[0].Text)
-		// Body blocks should have per-alert color
-		require.Equal(t, colorRed, blocks[1].Color)   // firing
-		require.Equal(t, colorGreen, blocks[2].Color) // resolved
-	})
-}
-
 func TestMSTeamsV2ReadingURLFromFile(t *testing.T) {
 	ctx, u, fn := test.GetContextWithCancelingURL()
 	defer fn()
@@ -327,16 +209,14 @@ func TestMSTeamsV2ReadingURLFromFile(t *testing.T) {
 	_, err = f.WriteString(u.String() + "\n")
 	require.NoError(t, err, "writing to temp file failed")
 
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.MSTeamsV2Config{
 			WebhookURLFile: f.Name(),
 			HTTPConfig:     &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		`{{ template "msteamsv2.default.titleLink" . }}`,
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 

pkg/alertmanager/alertmanagernotify/opsgenie/opsgenie.go

@@ -15,10 +15,7 @@ import (
 	"os"
 	"strings"
 
-	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer"
-	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
 
@@ -37,27 +34,25 @@ const maxMessageLenRunes = 130
 
 // Notifier implements a Notifier for OpsGenie notifications.
 type Notifier struct {
-	conf      *config.OpsGenieConfig
-	tmpl      *template.Template
-	logger    *slog.Logger
-	client    *http.Client
-	retrier   *notify.Retrier
-	templater alertmanagertypes.Templater
+	conf    *config.OpsGenieConfig
+	tmpl    *template.Template
+	logger  *slog.Logger
+	client  *http.Client
+	retrier *notify.Retrier
 }
 
 // New returns a new OpsGenie notifier.
-func New(c *config.OpsGenieConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+func New(c *config.OpsGenieConfig, t *template.Template, l *slog.Logger, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
 	client, err := notify.NewClientWithTracing(*c.HTTPConfig, Integration, httpOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return &Notifier{
-		conf:      c,
-		tmpl:      t,
-		logger:    l,
-		client:    client,
-		retrier:   &notify.Retrier{RetryCodes: []int{http.StatusTooManyRequests}},
-		templater: templater,
+		conf:    c,
+		tmpl:    t,
+		logger:  l,
+		client:  client,
+		retrier: &notify.Retrier{RetryCodes: []int{http.StatusTooManyRequests}},
 	}, nil
 }
 
@@ -128,55 +123,6 @@ func safeSplit(s, sep string) []string {
 	return b
 }
 
-// prepareContent expands alert templates and returns the OpsGenie-ready title
-// (truncated to the 130-rune limit) and HTML description. Custom bodies are
-// rendered to HTML and stitched together with <hr> dividers; default bodies
-// are joined with newlines (OpsGenie's legacy plain-text description).
-func (n *Notifier) prepareContent(ctx context.Context, alerts []*types.Alert) (string, string, error) {
-	customTitle, customBody := alertmanagertemplate.ExtractTemplatesFromAnnotations(alerts)
-	result, err := n.templater.Expand(ctx, alertmanagertypes.ExpandRequest{
-		TitleTemplate:        customTitle,
-		BodyTemplate:         customBody,
-		DefaultTitleTemplate: n.conf.Message,
-		DefaultBodyTemplate:  n.conf.Description,
-	}, alerts)
-	if err != nil {
-		return "", "", err
-	}
-
-	var description string
-	if result.IsDefaultBody {
-		description = strings.Join(result.Body, "\n")
-	} else {
-		var b strings.Builder
-		first := true
-		for _, part := range result.Body {
-			if part == "" {
-				continue
-			}
-			rendered, renderErr := markdownrenderer.RenderHTML(part)
-			if renderErr != nil {
-				return "", "", renderErr
-			}
-			if !first {
-				b.WriteString("<hr>")
-			}
-			b.WriteString("<div>")
-			b.WriteString(rendered)
-			b.WriteString("</div>")
-			first = false
-		}
-		description = b.String()
-	}
-
-	title, truncated := notify.TruncateInRunes(result.Title, maxMessageLenRunes)
-	if truncated {
-		n.logger.WarnContext(ctx, "Truncated message", slog.Int("max_runes", maxMessageLenRunes))
-	}
-
-	return title, description, nil
-}
-
 // Create requests for a list of alerts.
 func (n *Notifier) createRequests(ctx context.Context, as ...*types.Alert) ([]*http.Request, bool, error) {
 	key, err := notify.ExtractGroupKey(ctx)
@@ -222,10 +168,9 @@ func (n *Notifier) createRequests(ctx context.Context, as ...*types.Alert) ([]*h
 		}
 		requests = append(requests, req.WithContext(ctx))
 	default:
-		message, description, err := n.prepareContent(ctx, as)
-		if err != nil {
-			n.logger.ErrorContext(ctx, "failed to prepare notification content", errors.Attr(err))
-			return nil, false, err
+		message, truncated := notify.TruncateInRunes(tmpl(n.conf.Message), maxMessageLenRunes)
+		if truncated {
+			logger.WarnContext(ctx, "Truncated message", slog.Any("alert", key), slog.Int("max_runes", maxMessageLenRunes))
 		}
 
 		createEndpointURL := n.conf.APIURL.Copy()
@@ -264,7 +209,7 @@ func (n *Notifier) createRequests(ctx context.Context, as ...*types.Alert) ([]*h
 		msg := &opsGenieCreateMessage{
 			Alias:       alias,
 			Message:     message,
-			Description: description,
+			Description: tmpl(n.conf.Description),
 			Details:     details,
 			Source:      tmpl(n.conf.Source),
 			Responders:  responders,

pkg/alertmanager/alertmanagernotify/opsgenie/opsgenie_test.go

@@ -8,16 +8,12 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"log/slog"
 	"net/http"
 	"net/url"
 	"os"
 	"testing"
 	"time"
 
-	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
-	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
-	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/common/promslog"
@@ -26,23 +22,16 @@ import (
 	"github.com/prometheus/alertmanager/config"
 	"github.com/prometheus/alertmanager/notify"
 	"github.com/prometheus/alertmanager/notify/test"
-	"github.com/prometheus/alertmanager/template"
 	"github.com/prometheus/alertmanager/types"
 )
 
-func newTestTemplater(tmpl *template.Template) alertmanagertypes.Templater {
-	return alertmanagertemplate.New(tmpl, slog.New(slog.DiscardHandler))
-}
-
 func TestOpsGenieRetry(t *testing.T) {
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.OpsGenieConfig{
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -58,16 +47,14 @@ func TestOpsGenieRedactedURL(t *testing.T) {
 	defer fn()
 
 	key := "key"
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.OpsGenieConfig{
 			APIURL:     &config.URL{URL: u},
 			APIKey:     config.Secret(key),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -85,16 +72,14 @@ func TestGettingOpsGegineApikeyFromFile(t *testing.T) {
 	_, err = f.WriteString(key)
 	require.NoError(t, err, "writing to temp file failed")
 
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.OpsGenieConfig{
 			APIURL:     &config.URL{URL: u},
 			APIKeyFile: f.Name(),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -217,7 +202,7 @@ func TestOpsGenie(t *testing.T) {
 		},
 	} {
 		t.Run(tc.title, func(t *testing.T) {
-			notifier, err := New(tc.cfg, tmpl, logger, newTestTemplater(tmpl))
+			notifier, err := New(tc.cfg, tmpl, logger)
 			require.NoError(t, err)
 
 			ctx := context.Background()
@@ -293,7 +278,7 @@ func TestOpsGenieWithUpdate(t *testing.T) {
 		APIURL:       &config.URL{URL: u},
 		HTTPConfig:   &commoncfg.HTTPClientConfig{},
 	}
-	notifierWithUpdate, err := New(&opsGenieConfigWithUpdate, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl))
+	notifierWithUpdate, err := New(&opsGenieConfigWithUpdate, tmpl, promslog.NewNopLogger())
 	alert := &types.Alert{
 		Alert: model.Alert{
 			StartsAt: time.Now(),
@@ -336,7 +321,7 @@ func TestOpsGenieApiKeyFile(t *testing.T) {
 		APIURL:     &config.URL{URL: u},
 		HTTPConfig: &commoncfg.HTTPClientConfig{},
 	}
-	notifierWithUpdate, err := New(&opsGenieConfigWithUpdate, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl))
+	notifierWithUpdate, err := New(&opsGenieConfigWithUpdate, tmpl, promslog.NewNopLogger())
 
 	require.NoError(t, err)
 	requests, _, err := notifierWithUpdate.createRequests(ctx)
@@ -344,99 +329,6 @@ func TestOpsGenieApiKeyFile(t *testing.T) {
 	require.Equal(t, "GenieKey my_secret_api_key", requests[0].Header.Get("Authorization"))
 }
 
-func TestPrepareContent(t *testing.T) {
-	t.Run("default template", func(t *testing.T) {
-		tmpl := test.CreateTmpl(t)
-		logger := promslog.NewNopLogger()
-
-		notifier := &Notifier{
-			conf: &config.OpsGenieConfig{
-				Message:     `{{ .CommonLabels.Message }}`,
-				Description: `{{ .CommonLabels.Description }}`,
-			},
-			tmpl:      tmpl,
-			logger:    logger,
-			templater: newTestTemplater(tmpl),
-		}
-
-		ctx := context.Background()
-		ctx = notify.WithGroupKey(ctx, "1")
-
-		alert := &types.Alert{
-			Alert: model.Alert{
-				Labels: model.LabelSet{
-					"Message":     "Firing alert: test",
-					"Description": "Check runbook for more details",
-				},
-				StartsAt: time.Now(),
-				EndsAt:   time.Now().Add(time.Hour),
-			},
-		}
-
-		alerts := []*types.Alert{alert}
-
-		title, desc, prepErr := notifier.prepareContent(ctx, alerts)
-		require.NoError(t, prepErr)
-		require.Equal(t, "Firing alert: test", title)
-		require.Equal(t, "Check runbook for more details", desc)
-	})
-
-	t.Run("custom template", func(t *testing.T) {
-		tmpl := test.CreateTmpl(t)
-		logger := promslog.NewNopLogger()
-
-		notifier := &Notifier{
-			conf: &config.OpsGenieConfig{
-				Message:     `{{ .CommonLabels.Message }}`,
-				Description: `{{ .CommonLabels.Description }}`,
-			},
-			tmpl:      tmpl,
-			logger:    logger,
-			templater: newTestTemplater(tmpl),
-		}
-
-		ctx := context.Background()
-		ctx = notify.WithGroupKey(ctx, "1")
-
-		alert1 := &types.Alert{
-			Alert: model.Alert{
-				Labels: model.LabelSet{
-					"service":   "payment",
-					"namespace": "potter-the-harry",
-				},
-				Annotations: model.LabelSet{
-					ruletypes.AnnotationTitleTemplate: "High request throughput for $service",
-					ruletypes.AnnotationBodyTemplate:  "Alert firing in NS: $labels.namespace",
-				},
-				StartsAt: time.Now(),
-				EndsAt:   time.Now().Add(time.Hour),
-			},
-		}
-		alert2 := &types.Alert{
-			Alert: model.Alert{
-				Labels: model.LabelSet{
-					"service":   "payment",
-					"namespace": "smart-the-rat",
-				},
-				Annotations: model.LabelSet{
-					ruletypes.AnnotationTitleTemplate: "High request throughput for $service",
-					ruletypes.AnnotationBodyTemplate:  "Alert firing in NS: $labels.namespace",
-				},
-				StartsAt: time.Now(),
-				EndsAt:   time.Now().Add(time.Hour),
-			},
-		}
-
-		alerts := []*types.Alert{alert1, alert2}
-
-		title, desc, err := notifier.prepareContent(ctx, alerts)
-		require.NoError(t, err)
-		require.Equal(t, "High request throughput for payment", title)
-		// Each alert body wrapped in <div>, separated by <hr>
-		require.Equal(t, "<div><p>Alert firing in NS: potter-the-harry</p>\n</div><hr><div><p>Alert firing in NS: smart-the-rat</p>\n</div>", desc)
-	})
-}
-
 func readBody(t *testing.T, r *http.Request) string {
 	t.Helper()
 	body, err := io.ReadAll(r.Body)

pkg/alertmanager/alertmanagernotify/pagerduty/pagerduty.go

@@ -15,9 +15,7 @@ import (
 	"os"
 	"strings"
 
-	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/alecthomas/units"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
@@ -42,22 +40,21 @@ const (
 
 // Notifier implements a Notifier for PagerDuty notifications.
 type Notifier struct {
-	conf      *config.PagerdutyConfig
-	tmpl      *template.Template
-	logger    *slog.Logger
-	apiV1     string // for tests.
-	client    *http.Client
-	retrier   *notify.Retrier
-	templater alertmanagertypes.Templater
+	conf    *config.PagerdutyConfig
+	tmpl    *template.Template
+	logger  *slog.Logger
+	apiV1   string // for tests.
+	client  *http.Client
+	retrier *notify.Retrier
 }
 
 // New returns a new PagerDuty notifier.
-func New(c *config.PagerdutyConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+func New(c *config.PagerdutyConfig, t *template.Template, l *slog.Logger, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
 	client, err := notify.NewClientWithTracing(*c.HTTPConfig, Integration, httpOpts...)
 	if err != nil {
 		return nil, err
 	}
-	n := &Notifier{conf: c, tmpl: t, logger: l, client: client, templater: templater}
+	n := &Notifier{conf: c, tmpl: t, logger: l, client: client}
 	if c.ServiceKey != "" || c.ServiceKeyFile != "" {
 		n.apiV1 = "https://events.pagerduty.com/generic/2010-04-15/create_event.json"
 		// Retrying can solve the issue on 403 (rate limiting) and 5xx response codes.
@@ -146,12 +143,11 @@ func (n *Notifier) notifyV1(
 	key notify.Key,
 	data *template.Data,
 	details map[string]any,
-	title string,
 ) (bool, error) {
 	var tmplErr error
 	tmpl := notify.TmplText(n.tmpl, data, &tmplErr)
 
-	description, truncated := notify.TruncateInRunes(title, maxV1DescriptionLenRunes)
+	description, truncated := notify.TruncateInRunes(tmpl(n.conf.Description), maxV1DescriptionLenRunes)
 	if truncated {
 		n.logger.WarnContext(ctx, "Truncated description", slog.Any("key", key), slog.Int("max_runes", maxV1DescriptionLenRunes))
 	}
@@ -207,7 +203,6 @@ func (n *Notifier) notifyV2(
 	key notify.Key,
 	data *template.Data,
 	details map[string]any,
-	title string,
 ) (bool, error) {
 	var tmplErr error
 	tmpl := notify.TmplText(n.tmpl, data, &tmplErr)
@@ -216,7 +211,7 @@ func (n *Notifier) notifyV2(
 		n.conf.Severity = "error"
 	}
 
-	summary, truncated := notify.TruncateInRunes(title, maxV2SummaryLenRunes)
+	summary, truncated := notify.TruncateInRunes(tmpl(n.conf.Description), maxV2SummaryLenRunes)
 	if truncated {
 		n.logger.WarnContext(ctx, "Truncated summary", slog.Any("key", key), slog.Int("max_runes", maxV2SummaryLenRunes))
 	}
@@ -299,22 +294,6 @@ func (n *Notifier) notifyV2(
 	return retry, err
 }
 
-// prepareTitle expands the notification title. PagerDuty has no body surface
-// we care about — the description/summary field is what users see as the
-// incident headline, so we feed the configured Description as the default
-// title template and ignore any custom body_template entirely.
-func (n *Notifier) prepareTitle(ctx context.Context, alerts []*types.Alert) (string, error) {
-	customTitle, _ := alertmanagertemplate.ExtractTemplatesFromAnnotations(alerts)
-	result, err := n.templater.Expand(ctx, alertmanagertypes.ExpandRequest{
-		TitleTemplate:        customTitle,
-		DefaultTitleTemplate: n.conf.Description,
-	}, alerts)
-	if err != nil {
-		return "", err
-	}
-	return result.Title, nil
-}
-
 // Notify implements the Notifier interface.
 func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {
 	key, err := notify.ExtractGroupKey(ctx)
@@ -323,12 +302,6 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 	}
 	logger := n.logger.With(slog.Any("group_key", key))
 
-	title, err := n.prepareTitle(ctx, as)
-	if err != nil {
-		n.logger.ErrorContext(ctx, "failed to prepare notification content", errors.Attr(err))
-		return false, err
-	}
-
 	var (
 		alerts    = types.Alerts(as...)
 		data      = notify.GetTemplateData(ctx, n.tmpl, as, logger)
@@ -356,7 +329,7 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 	if n.apiV1 != "" {
 		nf = n.notifyV1
 	}
-	retry, err := nf(ctx, eventType, key, data, details, title)
+	retry, err := nf(ctx, eventType, key, data, details)
 	if err != nil {
 		if ctx.Err() != nil {
 			err = errors.WrapInternalf(err, errors.CodeInternal, "failed to notify PagerDuty: %v", context.Cause(ctx))

pkg/alertmanager/alertmanagernotify/pagerduty/pagerduty_test.go

@@ -9,7 +9,6 @@ import (
 	"context"
 	"encoding/json"
 	"io"
-	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
@@ -18,10 +17,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
-	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/common/promslog"
@@ -34,20 +30,14 @@ import (
 	"github.com/prometheus/alertmanager/types"
 )
 
-func newTestTemplater(tmpl *template.Template) alertmanagertypes.Templater {
-	return alertmanagertemplate.New(tmpl, slog.New(slog.DiscardHandler))
-}
-
 func TestPagerDutyRetryV1(t *testing.T) {
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.PagerdutyConfig{
 			ServiceKey: config.Secret("01234567890123456789012345678901"),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -59,15 +49,13 @@ func TestPagerDutyRetryV1(t *testing.T) {
 }
 
 func TestPagerDutyRetryV2(t *testing.T) {
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.PagerdutyConfig{
 			RoutingKey: config.Secret("01234567890123456789012345678901"),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -83,15 +71,13 @@ func TestPagerDutyRedactedURLV1(t *testing.T) {
 	defer fn()
 
 	key := "01234567890123456789012345678901"
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.PagerdutyConfig{
 			ServiceKey: config.Secret(key),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 	notifier.apiV1 = u.String()
@@ -104,16 +90,14 @@ func TestPagerDutyRedactedURLV2(t *testing.T) {
 	defer fn()
 
 	key := "01234567890123456789012345678901"
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.PagerdutyConfig{
 			URL:        &config.URL{URL: u},
 			RoutingKey: config.Secret(key),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -130,15 +114,13 @@ func TestPagerDutyV1ServiceKeyFromFile(t *testing.T) {
 	ctx, u, fn := test.GetContextWithCancelingURL()
 	defer fn()
 
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.PagerdutyConfig{
 			ServiceKeyFile: f.Name(),
 			HTTPConfig:     &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 	notifier.apiV1 = u.String()
@@ -156,16 +138,14 @@ func TestPagerDutyV2RoutingKeyFromFile(t *testing.T) {
 	ctx, u, fn := test.GetContextWithCancelingURL()
 	defer fn()
 
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.PagerdutyConfig{
 			URL:            &config.URL{URL: u},
 			RoutingKeyFile: f.Name(),
 			HTTPConfig:     &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -322,8 +302,7 @@ func TestPagerDutyTemplating(t *testing.T) {
 		t.Run(tc.title, func(t *testing.T) {
 			tc.cfg.URL = &config.URL{URL: u}
 			tc.cfg.HTTPConfig = &commoncfg.HTTPClientConfig{}
-			tmpl := test.CreateTmpl(t)
-			pd, err := New(tc.cfg, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl))
+			pd, err := New(tc.cfg, test.CreateTmpl(t), promslog.NewNopLogger())
 			require.NoError(t, err)
 			if pd.apiV1 != "" {
 				pd.apiV1 = u.String()
@@ -413,15 +392,13 @@ func TestEventSizeEnforcement(t *testing.T) {
 		Details:    bigDetailsV1,
 	}
 
-	tmpl := test.CreateTmpl(t)
 	notifierV1, err := New(
 		&config.PagerdutyConfig{
 			ServiceKey: config.Secret("01234567890123456789012345678901"),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -443,9 +420,8 @@ func TestEventSizeEnforcement(t *testing.T) {
 			RoutingKey: config.Secret("01234567890123456789012345678901"),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -560,8 +536,7 @@ func TestPagerDutyEmptySrcHref(t *testing.T) {
 		Links:      links,
 	}
 
-	pdTmpl := test.CreateTmpl(t)
-	pagerDuty, err := New(&pagerDutyConfig, pdTmpl, promslog.NewNopLogger(), newTestTemplater(pdTmpl))
+	pagerDuty, err := New(&pagerDutyConfig, test.CreateTmpl(t), promslog.NewNopLogger())
 	require.NoError(t, err)
 
 	ctx := context.Background()
@@ -628,8 +603,7 @@ func TestPagerDutyTimeout(t *testing.T) {
 				Timeout:    tt.timeout,
 			}
 
-			tmpl := test.CreateTmpl(t)
-			pd, err := New(&cfg, tmpl, promslog.NewNopLogger(), newTestTemplater(tmpl))
+			pd, err := New(&cfg, test.CreateTmpl(t), promslog.NewNopLogger())
 			require.NoError(t, err)
 
 			ctx := context.Background()
@@ -907,79 +881,3 @@ func TestRenderDetails(t *testing.T) {
 		})
 	}
 }
-
-func TestPrepareContent(t *testing.T) {
-	prepareContext := func() context.Context {
-		ctx := context.Background()
-		ctx = notify.WithGroupKey(ctx, "1")
-		ctx = notify.WithReceiverName(ctx, "test-receiver")
-		ctx = notify.WithGroupLabels(ctx, model.LabelSet{"alertname": "HighCPU for Payment service"})
-		return ctx
-	}
-	t.Run("default template uses go text template config for title", func(t *testing.T) {
-		tmpl := test.CreateTmpl(t)
-		notifier, err := New(
-			&config.PagerdutyConfig{
-				RoutingKey:  config.Secret("01234567890123456789012345678901"),
-				HTTPConfig:  &commoncfg.HTTPClientConfig{},
-				Description: `{{ .CommonLabels.alertname }} ({{ .Status | toUpper }})`,
-			},
-			tmpl,
-			promslog.NewNopLogger(),
-			newTestTemplater(tmpl),
-		)
-		require.NoError(t, err)
-
-		ctx := prepareContext()
-
-		alerts := []*types.Alert{
-			{
-				Alert: model.Alert{
-					Labels:   model.LabelSet{"alertname": "HighCPU for Payment service"},
-					StartsAt: time.Now(),
-					EndsAt:   time.Now().Add(time.Hour),
-				},
-			},
-		}
-
-		title, err := notifier.prepareTitle(ctx, alerts)
-		require.NoError(t, err)
-		require.Equal(t, "HighCPU for Payment service (FIRING)", title)
-	})
-
-	t.Run("custom template uses $variable annotation for title", func(t *testing.T) {
-		tmpl := test.CreateTmpl(t)
-		notifier, err := New(
-			&config.PagerdutyConfig{
-				RoutingKey: config.Secret("01234567890123456789012345678901"),
-				HTTPConfig: &commoncfg.HTTPClientConfig{},
-			},
-			tmpl,
-			promslog.NewNopLogger(),
-			newTestTemplater(tmpl),
-		)
-		require.NoError(t, err)
-
-		ctx := prepareContext()
-
-		alerts := []*types.Alert{
-			{
-				Alert: model.Alert{
-					Labels: model.LabelSet{
-						"alertname": "HighCPU",
-						"service":   "api-server",
-					},
-					Annotations: model.LabelSet{
-						ruletypes.AnnotationTitleTemplate: "$rule.name on $service is in $alert.status state",
-					},
-					StartsAt: time.Now().Add(-time.Hour),
-					EndsAt:   time.Now(),
-				},
-			},
-		}
-
-		title, err := notifier.prepareTitle(ctx, alerts)
-		require.NoError(t, err)
-		require.Equal(t, "HighCPU on api-server is in resolved state", title)
-	})
-}

pkg/alertmanager/alertmanagernotify/receiver.go

@@ -26,7 +26,7 @@ var customNotifierIntegrations = []string{
 	msteamsv2.Integration,
 }
 
-func NewReceiverIntegrations(nc alertmanagertypes.Receiver, tmpl *template.Template, logger *slog.Logger, templater alertmanagertypes.Templater) ([]notify.Integration, error) {
+func NewReceiverIntegrations(nc alertmanagertypes.Receiver, tmpl *template.Template, logger *slog.Logger) ([]notify.Integration, error) {
 	upstreamIntegrations, err := receiver.BuildReceiverIntegrations(nc, tmpl, logger)
 	if err != nil {
 		return nil, err
@@ -53,25 +53,23 @@ func NewReceiverIntegrations(nc alertmanagertypes.Receiver, tmpl *template.Templ
 	}
 
 	for i, c := range nc.WebhookConfigs {
-		add(webhook.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return webhook.New(c, tmpl, l, templater) })
+		add(webhook.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return webhook.New(c, tmpl, l) })
 	}
 	for i, c := range nc.EmailConfigs {
-		add(email.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) {
-			return email.New(c, tmpl, l, templater), nil
-		})
+		add(email.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return email.New(c, tmpl, l), nil })
 	}
 	for i, c := range nc.PagerdutyConfigs {
-		add(pagerduty.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return pagerduty.New(c, tmpl, l, templater) })
+		add(pagerduty.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return pagerduty.New(c, tmpl, l) })
 	}
 	for i, c := range nc.OpsGenieConfigs {
-		add(opsgenie.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return opsgenie.New(c, tmpl, l, templater) })
+		add(opsgenie.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return opsgenie.New(c, tmpl, l) })
 	}
 	for i, c := range nc.SlackConfigs {
-		add(slack.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return slack.New(c, tmpl, l, templater) })
+		add(slack.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) { return slack.New(c, tmpl, l) })
 	}
 	for i, c := range nc.MSTeamsV2Configs {
 		add(msteamsv2.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) {
-			return msteamsv2.New(c, tmpl, `{{ template "msteamsv2.default.titleLink" . }}`, l, templater)
+			return msteamsv2.New(c, tmpl, `{{ template "msteamsv2.default.titleLink" . }}`, l)
 		})
 	}
 

pkg/alertmanager/alertmanagernotify/slack/slack.go

@@ -14,11 +14,7 @@ import (
 	"os"
 	"strings"
 
-	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer"
-	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
-	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	commoncfg "github.com/prometheus/common/config"
 
 	"github.com/prometheus/alertmanager/config"
@@ -29,8 +25,6 @@ import (
 
 const (
 	Integration = "slack"
-	colorRed    = "#FF0000"
-	colorGreen  = "#00FF00"
 )
 
 // https://api.slack.com/reference/messaging/attachments#legacy_fields - 1024, no units given, assuming runes or characters.
@@ -38,18 +32,17 @@ const maxTitleLenRunes = 1024
 
 // Notifier implements a Notifier for Slack notifications.
 type Notifier struct {
-	conf      *config.SlackConfig
-	tmpl      *template.Template
-	logger    *slog.Logger
-	client    *http.Client
-	retrier   *notify.Retrier
-	templater alertmanagertypes.Templater
+	conf    *config.SlackConfig
+	tmpl    *template.Template
+	logger  *slog.Logger
+	client  *http.Client
+	retrier *notify.Retrier
 
 	postJSONFunc func(ctx context.Context, client *http.Client, url string, body io.Reader) (*http.Response, error)
 }
 
 // New returns a new Slack notification handler.
-func New(c *config.SlackConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+func New(c *config.SlackConfig, t *template.Template, l *slog.Logger, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
 	client, err := notify.NewClientWithTracing(*c.HTTPConfig, Integration, httpOpts...)
 	if err != nil {
 		return nil, err
@@ -61,7 +54,6 @@ func New(c *config.SlackConfig, t *template.Template, l *slog.Logger, templater
 		logger:       l,
 		client:       client,
 		retrier:      &notify.Retrier{},
-		templater:    templater,
 		postJSONFunc: notify.PostJSON,
 	}, nil
 }
@@ -89,10 +81,9 @@ type attachment struct {
 	Actions    []config.SlackAction `json:"actions,omitempty"`
 	ImageURL   string               `json:"image_url,omitempty"`
 	ThumbURL   string               `json:"thumb_url,omitempty"`
-	Footer     string               `json:"footer,omitempty"`
+	Footer     string               `json:"footer"`
 	Color      string               `json:"color,omitempty"`
 	MrkdwnIn   []string             `json:"mrkdwn_in,omitempty"`
-	Blocks     []any                `json:"blocks,omitempty"`
 }
 
 // Notify implements the Notifier interface.
@@ -109,15 +100,79 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 		data     = notify.GetTemplateData(ctx, n.tmpl, as, logger)
 		tmplText = notify.TmplText(n.tmpl, data, &err)
 	)
+	var markdownIn []string
 
-	attachments, err := n.prepareContent(ctx, as, tmplText)
-	if err != nil {
-		n.logger.ErrorContext(ctx, "failed to prepare notification content", errors.Attr(err))
-		return false, err
+	if len(n.conf.MrkdwnIn) == 0 {
+		markdownIn = []string{"fallback", "pretext", "text"}
+	} else {
+		markdownIn = n.conf.MrkdwnIn
 	}
 
-	if len(attachments) > 0 {
-		n.addFieldsAndActions(&attachments[0], tmplText)
+	title, truncated := notify.TruncateInRunes(tmplText(n.conf.Title), maxTitleLenRunes)
+	if truncated {
+		logger.WarnContext(ctx, "Truncated title", slog.Int("max_runes", maxTitleLenRunes))
+	}
+	att := &attachment{
+		Title:      title,
+		TitleLink:  tmplText(n.conf.TitleLink),
+		Pretext:    tmplText(n.conf.Pretext),
+		Text:       tmplText(n.conf.Text),
+		Fallback:   tmplText(n.conf.Fallback),
+		CallbackID: tmplText(n.conf.CallbackID),
+		ImageURL:   tmplText(n.conf.ImageURL),
+		ThumbURL:   tmplText(n.conf.ThumbURL),
+		Footer:     tmplText(n.conf.Footer),
+		Color:      tmplText(n.conf.Color),
+		MrkdwnIn:   markdownIn,
+	}
+
+	numFields := len(n.conf.Fields)
+	if numFields > 0 {
+		fields := make([]config.SlackField, numFields)
+		for index, field := range n.conf.Fields {
+			// Check if short was defined for the field otherwise fallback to the global setting
+			var short bool
+			if field.Short != nil {
+				short = *field.Short
+			} else {
+				short = n.conf.ShortFields
+			}
+
+			// Rebuild the field by executing any templates and setting the new value for short
+			fields[index] = config.SlackField{
+				Title: tmplText(field.Title),
+				Value: tmplText(field.Value),
+				Short: &short,
+			}
+		}
+		att.Fields = fields
+	}
+
+	numActions := len(n.conf.Actions)
+	if numActions > 0 {
+		actions := make([]config.SlackAction, numActions)
+		for index, action := range n.conf.Actions {
+			slackAction := config.SlackAction{
+				Type:  tmplText(action.Type),
+				Text:  tmplText(action.Text),
+				URL:   tmplText(action.URL),
+				Style: tmplText(action.Style),
+				Name:  tmplText(action.Name),
+				Value: tmplText(action.Value),
+			}
+
+			if action.ConfirmField != nil {
+				slackAction.ConfirmField = &config.SlackConfirmationField{
+					Title:       tmplText(action.ConfirmField.Title),
+					Text:        tmplText(action.ConfirmField.Text),
+					OkText:      tmplText(action.ConfirmField.OkText),
+					DismissText: tmplText(action.ConfirmField.DismissText),
+				}
+			}
+
+			actions[index] = slackAction
+		}
+		att.Actions = actions
 	}
 
 	req := &request{
@@ -127,7 +182,7 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 		IconURL:     tmplText(n.conf.IconURL),
 		LinkNames:   n.conf.LinkNames,
 		Text:        tmplText(n.conf.MessageText),
-		Attachments: attachments,
+		Attachments: []attachment{*att},
 	}
 	if err != nil {
 		return false, err
@@ -183,150 +238,6 @@ func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error)
 	return retry, nil
 }
 
-// prepareContent expands alert templates and returns the Slack attachment(s)
-// ready to send. When alerts carry a custom body template, one title-only
-// attachment plus one body attachment per alert is returned so that each alert
-// can get its own firing/resolved color and per-alert action buttons.
-func (n *Notifier) prepareContent(ctx context.Context, alerts []*types.Alert, tmplText func(string) string) ([]attachment, error) {
-	customTitle, customBody := alertmanagertemplate.ExtractTemplatesFromAnnotations(alerts)
-	result, err := n.templater.Expand(ctx, alertmanagertypes.ExpandRequest{
-		TitleTemplate:        customTitle,
-		BodyTemplate:         customBody,
-		DefaultTitleTemplate: n.conf.Title,
-		DefaultBodyTemplate:  n.conf.Text,
-	}, alerts)
-	if err != nil {
-		return nil, err
-	}
-
-	title, truncated := notify.TruncateInRunes(result.Title, maxTitleLenRunes)
-	if truncated {
-		n.logger.WarnContext(ctx, "Truncated title", slog.Int("max_runes", maxTitleLenRunes))
-	}
-
-	if result.IsDefaultBody {
-		var markdownIn []string
-		if len(n.conf.MrkdwnIn) == 0 {
-			markdownIn = []string{"fallback", "pretext", "text"}
-		} else {
-			markdownIn = n.conf.MrkdwnIn
-		}
-		return []attachment{
-			{
-				Title:      title,
-				TitleLink:  tmplText(n.conf.TitleLink),
-				Pretext:    tmplText(n.conf.Pretext),
-				Text:       result.Body[0],
-				Fallback:   tmplText(n.conf.Fallback),
-				CallbackID: tmplText(n.conf.CallbackID),
-				ImageURL:   tmplText(n.conf.ImageURL),
-				ThumbURL:   tmplText(n.conf.ThumbURL),
-				Footer:     tmplText(n.conf.Footer),
-				Color:      tmplText(n.conf.Color),
-				MrkdwnIn:   markdownIn,
-			},
-		}, nil
-	}
-
-	// Custom template path: one title attachment + one attachment per
-	// non-empty alert body. result.Body is positionally aligned with alerts,
-	// so we index alerts[i] directly and skip empty entries.
-	attachments := make([]attachment, 0, 1+len(result.Body))
-	attachments = append(attachments, attachment{
-		Title:     title,
-		TitleLink: tmplText(n.conf.TitleLink),
-	})
-
-	for i, body := range result.Body {
-		if body == "" || i >= len(alerts) {
-			continue
-		}
-
-		// Custom bodies are authored in markdown; render each non-empty body to
-		// Slack's mrkdwn flavour. Default bodies skip this because the Text
-		// template is already channel-ready.
-		rendered, renderErr := markdownrenderer.RenderSlackMrkdwn(body)
-		if renderErr != nil {
-			return nil, renderErr
-		}
-
-		color := colorRed
-		if alerts[i].Resolved() {
-			color = colorGreen
-		}
-		attachments = append(attachments, attachment{
-			Text:     rendered,
-			Color:    color,
-			MrkdwnIn: []string{"text"},
-			Actions:  buildRelatedLinkActions(alerts[i]),
-		})
-	}
-
-	return attachments, nil
-}
-
-// buildRelatedLinkActions returns the "View Related Logs/Traces" action
-// buttons for an alert, or nil when no related-link annotations are present.
-func buildRelatedLinkActions(alert *types.Alert) []config.SlackAction {
-	var actions []config.SlackAction
-	if link := alert.Annotations[ruletypes.AnnotationRelatedLogs]; link != "" {
-		actions = append(actions, config.SlackAction{Type: "button", Text: "View Related Logs", URL: string(link)})
-	}
-	if link := alert.Annotations[ruletypes.AnnotationRelatedTraces]; link != "" {
-		actions = append(actions, config.SlackAction{Type: "button", Text: "View Related Traces", URL: string(link)})
-	}
-	return actions
-}
-
-// addFieldsAndActions populates fields and actions on the attachment from the Slack config.
-func (n *Notifier) addFieldsAndActions(att *attachment, tmplText func(string) string) {
-	numFields := len(n.conf.Fields)
-	if numFields > 0 {
-		fields := make([]config.SlackField, numFields)
-		for index, field := range n.conf.Fields {
-			var short bool
-			if field.Short != nil {
-				short = *field.Short
-			} else {
-				short = n.conf.ShortFields
-			}
-			fields[index] = config.SlackField{
-				Title: tmplText(field.Title),
-				Value: tmplText(field.Value),
-				Short: &short,
-			}
-		}
-		att.Fields = fields
-	}
-
-	numActions := len(n.conf.Actions)
-	if numActions > 0 {
-		actions := make([]config.SlackAction, numActions)
-		for index, action := range n.conf.Actions {
-			slackAction := config.SlackAction{
-				Type:  tmplText(action.Type),
-				Text:  tmplText(action.Text),
-				URL:   tmplText(action.URL),
-				Style: tmplText(action.Style),
-				Name:  tmplText(action.Name),
-				Value: tmplText(action.Value),
-			}
-
-			if action.ConfirmField != nil {
-				slackAction.ConfirmField = &config.SlackConfirmationField{
-					Title:       tmplText(action.ConfirmField.Title),
-					Text:        tmplText(action.ConfirmField.Text),
-					OkText:      tmplText(action.ConfirmField.OkText),
-					DismissText: tmplText(action.ConfirmField.DismissText),
-				}
-			}
-
-			actions[index] = slackAction
-		}
-		att.Actions = actions
-	}
-}
-
 // checkResponseError parses out the error message from Slack API response.
 func checkResponseError(resp *http.Response) (bool, error) {
 	body, err := io.ReadAll(resp.Body)

pkg/alertmanager/alertmanagernotify/slack/slack_test.go

@@ -17,9 +17,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
-	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
-	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	commoncfg "github.com/prometheus/common/config"
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/common/promslog"
@@ -32,19 +29,13 @@ import (
 	"github.com/prometheus/alertmanager/types"
 )
 
-func newTestTemplater(tmpl *template.Template) alertmanagertypes.Templater {
-	return alertmanagertemplate.New(tmpl, slog.New(slog.DiscardHandler))
-}
-
 func TestSlackRetry(t *testing.T) {
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.SlackConfig{
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -58,15 +49,13 @@ func TestSlackRedactedURL(t *testing.T) {
 	ctx, u, fn := test.GetContextWithCancelingURL()
 	defer fn()
 
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.SlackConfig{
 			APIURL:     &config.SecretURL{URL: u},
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -82,15 +71,13 @@ func TestGettingSlackURLFromFile(t *testing.T) {
 	_, err = f.WriteString(u.String())
 	require.NoError(t, err, "writing to temp file failed")
 
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.SlackConfig{
 			APIURLFile: f.Name(),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -106,15 +93,13 @@ func TestTrimmingSlackURLFromFile(t *testing.T) {
 	_, err = f.WriteString(u.String() + "\n\n")
 	require.NoError(t, err, "writing to temp file failed")
 
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.SlackConfig{
 			APIURLFile: f.Name(),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		newTestTemplater(tmpl),
 	)
 	require.NoError(t, err)
 
@@ -199,7 +184,6 @@ func TestNotifier_Notify_WithReason(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			apiurl, _ := url.Parse("https://slack.com/post.Message")
-			tmpl := test.CreateTmpl(t)
 			notifier, err := New(
 				&config.SlackConfig{
 					NotifierConfig: config.NotifierConfig{},
@@ -207,9 +191,8 @@ func TestNotifier_Notify_WithReason(t *testing.T) {
 					APIURL:         &config.SecretURL{URL: apiurl},
 					Channel:        "channelname",
 				},
-				tmpl,
+				test.CreateTmpl(t),
 				promslog.NewNopLogger(),
-				newTestTemplater(tmpl),
 			)
 			require.NoError(t, err)
 
@@ -259,7 +242,6 @@ func TestSlackTimeout(t *testing.T) {
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
 			u, _ := url.Parse("https://slack.com/post.Message")
-			tmpl := test.CreateTmpl(t)
 			notifier, err := New(
 				&config.SlackConfig{
 					NotifierConfig: config.NotifierConfig{},
@@ -268,9 +250,8 @@ func TestSlackTimeout(t *testing.T) {
 					Channel:        "channelname",
 					Timeout:        tt.timeout,
 				},
-				tmpl,
+				test.CreateTmpl(t),
 				promslog.NewNopLogger(),
-				newTestTemplater(tmpl),
 			)
 			require.NoError(t, err)
 			notifier.postJSONFunc = func(ctx context.Context, client *http.Client, url string, body io.Reader) (*http.Response, error) {
@@ -301,225 +282,6 @@ func TestSlackTimeout(t *testing.T) {
 	}
 }
 
-// setupTestContext creates a context with group key, receiver name, and group labels
-// required by the notification processor.
-func setupTestContext() context.Context {
-	ctx := context.Background()
-	ctx = notify.WithGroupKey(ctx, "test-group")
-	ctx = notify.WithReceiverName(ctx, "slack")
-	ctx = notify.WithGroupLabels(ctx, model.LabelSet{
-		"alertname": "TestAlert",
-		"severity":  "critical",
-	})
-	return ctx
-}
-
-func TestPrepareContent(t *testing.T) {
-	t.Run("default template uses go text template config for title and body", func(t *testing.T) {
-		// When alerts have no custom annotation templates (title_template / body_template),
-		tmpl := test.CreateTmpl(t)
-		templater := newTestTemplater(tmpl)
-		notifier := &Notifier{
-			conf: &config.SlackConfig{
-				Title:     `{{ .CommonLabels.alertname }} ({{ .Status | toUpper }})`,
-				Text:      `{{ range .Alerts }}Alert: {{ .Labels.alertname }} - severity {{ .Labels.severity }}{{ end }}`,
-				Color:     `{{ if eq .Status "firing" }}danger{{ else }}good{{ end }}`,
-				TitleLink: "https://alertmanager.signoz.com",
-			},
-			tmpl:      tmpl,
-			logger:    slog.New(slog.DiscardHandler),
-			templater: templater,
-		}
-
-		ctx := setupTestContext()
-		alerts := []*types.Alert{
-			{Alert: model.Alert{
-				Labels:   model.LabelSet{ruletypes.LabelAlertName: "HighCPU", ruletypes.LabelSeverityName: "critical"},
-				StartsAt: time.Now(),
-				EndsAt:   time.Now().Add(time.Hour),
-			}},
-		}
-
-		// Build tmplText the same way Notify does
-		var err error
-		data := notify.GetTemplateData(ctx, tmpl, alerts, slog.New(slog.DiscardHandler))
-		tmplText := notify.TmplText(tmpl, data, &err)
-
-		atts, attErr := notifier.prepareContent(ctx, alerts, tmplText)
-		require.NoError(t, attErr)
-		require.NoError(t, err)
-		require.Len(t, atts, 1)
-
-		require.Equal(t, "HighCPU (FIRING)", atts[0].Title)
-		require.Equal(t, "Alert: HighCPU - severity critical", atts[0].Text)
-		// Color is templated — firing alert should be "danger"
-		require.Equal(t, "danger", atts[0].Color)
-		// No BlockKit blocks for default template
-		require.Nil(t, atts[0].Blocks)
-		// Default markdownIn when config has none
-		require.Equal(t, []string{"fallback", "pretext", "text"}, atts[0].MrkdwnIn)
-	})
-
-	t.Run("custom template produces 1+N attachments with per-alert color", func(t *testing.T) {
-		// When alerts carry custom $variable annotation templates (title_template / body_template)
-		tmpl := test.CreateTmpl(t)
-		templater := newTestTemplater(tmpl)
-		notifier := &Notifier{
-			conf: &config.SlackConfig{
-				Title:     "default title fallback",
-				Text:      "default text fallback",
-				TitleLink: "https://alertmanager.signoz.com",
-			},
-			tmpl:      tmpl,
-			logger:    slog.New(slog.DiscardHandler),
-			templater: templater,
-		}
-		tmplText := func(s string) string { return s }
-
-		bodyTemplate := `## $rule.name
-
-**Service:** *$labels.service*
-**Instance:** *$labels.instance*
-**Region:** *$labels.region*
-**Method:** *$labels.http_method*
-
----
-
-| Metric | Value |
-|--------|-------|
-| **Current** | *$value* |
-| **Threshold** | *$threshold.value* |
-
-**Status:** $alert.status | **Severity:** $labels.severity`
-		titleTemplate := "[$alert.status] $rule.name — $labels.service"
-
-		ctx := setupTestContext()
-		firingAlert := &types.Alert{
-			Alert: model.Alert{
-				Labels:   model.LabelSet{ruletypes.LabelAlertName: "HighCPU", ruletypes.LabelSeverityName: "critical", "service": "api-server", "instance": "i-0abc123", "region": "us-east-1", "http_method": "GET"},
-				StartsAt: time.Now(),
-				EndsAt:   time.Now().Add(time.Hour),
-				Annotations: model.LabelSet{
-					ruletypes.AnnotationTitleTemplate: model.LabelValue(titleTemplate),
-					ruletypes.AnnotationBodyTemplate:  model.LabelValue(bodyTemplate),
-					"value":                           "100",
-					"threshold.value":                 "200",
-				},
-			},
-		}
-		resolvedAlert := &types.Alert{
-			Alert: model.Alert{
-				Labels:   model.LabelSet{ruletypes.LabelAlertName: "HighCPU", ruletypes.LabelSeverityName: "critical", "service": "api-server", "instance": "i-0abc123", "region": "us-east-1", "http_method": "GET"},
-				StartsAt: time.Now().Add(-2 * time.Hour),
-				EndsAt:   time.Now().Add(-time.Hour),
-				Annotations: model.LabelSet{
-					ruletypes.AnnotationTitleTemplate: model.LabelValue(titleTemplate),
-					ruletypes.AnnotationBodyTemplate:  model.LabelValue(bodyTemplate),
-					"value":                           "50",
-					"threshold.value":                 "200",
-				},
-			},
-		}
-
-		atts, err := notifier.prepareContent(ctx, []*types.Alert{firingAlert, resolvedAlert}, tmplText)
-		require.NoError(t, err)
-
-		// 1 title attachment + 2 body attachments (one per alert)
-		require.Len(t, atts, 3)
-
-		// First attachment: title-only, no color, no blocks
-		require.Equal(t, "[firing] HighCPU — api-server", atts[0].Title)
-		require.Empty(t, atts[0].Color)
-		require.Nil(t, atts[0].Blocks)
-		require.Equal(t, "https://alertmanager.signoz.com", atts[0].TitleLink)
-
-		expectedFiringBody := "*HighCPU*\n\n" +
-			"*Service:* _api-server_\n*Instance:* _i-0abc123_\n*Region:* _us-east-1_\n*Method:* _GET_\n\n" +
-			"---\n\n" +
-			"```\nMetric    | Value\n----------|------\nCurrent   | 100  \nThreshold | 200  \n```\n\n" +
-			"*Status:* firing | *Severity:* critical\n\n"
-
-		expectedResolvedBody := "*HighCPU*\n\n" +
-			"*Service:* _api-server_\n*Instance:* _i-0abc123_\n*Region:* _us-east-1_\n*Method:* _GET_\n\n" +
-			"---\n\n" +
-			"```\nMetric    | Value\n----------|------\nCurrent   | 50   \nThreshold | 200  \n```\n\n" +
-			"*Status:* resolved | *Severity:* critical\n\n"
-
-		// Second attachment: firing alert body rendered as slack mrkdwn text, red color
-		require.Nil(t, atts[1].Blocks)
-		require.Equal(t, "#FF0000", atts[1].Color)
-		require.Equal(t, []string{"text"}, atts[1].MrkdwnIn)
-		require.Equal(t, expectedFiringBody, atts[1].Text)
-
-		// Third attachment: resolved alert body rendered as slack mrkdwn text, green color
-		require.Nil(t, atts[2].Blocks)
-		require.Equal(t, "#00FF00", atts[2].Color)
-		require.Equal(t, []string{"text"}, atts[2].MrkdwnIn)
-		require.Equal(t, expectedResolvedBody, atts[2].Text)
-	})
-
-	t.Run("default template with fields and actions", func(t *testing.T) {
-		// Verifies that addFieldsAndActions (called from Notify after prepareContent)
-		// correctly populates fields and actions on the attachment from config.
-		tmpl := test.CreateTmpl(t)
-		templater := newTestTemplater(tmpl)
-		short := true
-		notifier := &Notifier{
-			conf: &config.SlackConfig{
-				Title: `{{ .CommonLabels.alertname }}`,
-				Text:  "alert text",
-				Color: "warning",
-				Fields: []*config.SlackField{
-					{Title: "Severity", Value: "critical", Short: &short},
-					{Title: "Service", Value: "api-server", Short: &short},
-				},
-				Actions: []*config.SlackAction{
-					{Type: "button", Text: "View Alert", URL: "https://alertmanager.signoz.com"},
-				},
-				TitleLink: "https://alertmanager.signoz.com",
-			},
-			tmpl:      tmpl,
-			logger:    slog.New(slog.DiscardHandler),
-			templater: templater,
-		}
-		tmplText := func(s string) string { return s }
-
-		ctx := setupTestContext()
-		alerts := []*types.Alert{
-			{Alert: model.Alert{
-				Labels:   model.LabelSet{ruletypes.LabelAlertName: "TestAlert"},
-				StartsAt: time.Now(),
-				EndsAt:   time.Now().Add(time.Hour),
-			}},
-		}
-		atts, err := notifier.prepareContent(ctx, alerts, tmplText)
-		require.NoError(t, err)
-		require.Len(t, atts, 1)
-
-		// prepareContent does not populate fields/actions — that's done by
-		// addFieldsAndActions which is called from Notify.
-		require.Nil(t, atts[0].Fields)
-		require.Nil(t, atts[0].Actions)
-
-		// Simulate what Notify does after prepareContent
-		notifier.addFieldsAndActions(&atts[0], tmplText)
-
-		// Verify fields
-		require.Len(t, atts[0].Fields, 2)
-		require.Equal(t, "Severity", atts[0].Fields[0].Title)
-		require.Equal(t, "critical", atts[0].Fields[0].Value)
-		require.True(t, *atts[0].Fields[0].Short)
-		require.Equal(t, "Service", atts[0].Fields[1].Title)
-		require.Equal(t, "api-server", atts[0].Fields[1].Value)
-
-		// Verify actions
-		require.Len(t, atts[0].Actions, 1)
-		require.Equal(t, "button", atts[0].Actions[0].Type)
-		require.Equal(t, "View Alert", atts[0].Actions[0].Text)
-		require.Equal(t, "https://alertmanager.signoz.com", atts[0].Actions[0].URL)
-	})
-}
-
 func TestSlackMessageField(t *testing.T) {
 	// 1. Setup a fake Slack server
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -567,7 +329,7 @@ func TestSlackMessageField(t *testing.T) {
 	tmpl.ExternalURL = u
 
 	logger := slog.New(slog.DiscardHandler)
-	notifier, err := New(conf, tmpl, logger, newTestTemplater(tmpl))
+	notifier, err := New(conf, tmpl, logger)
 	if err != nil {
 		t.Fatal(err)
 	}

pkg/alertmanager/alertmanagernotify/webhook/webhook.go

@@ -14,7 +14,6 @@ import (
 	"strings"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	commoncfg "github.com/prometheus/common/config"
 
 	"github.com/prometheus/alertmanager/config"
@@ -29,16 +28,15 @@ const (
 
 // Notifier implements a Notifier for generic webhooks.
 type Notifier struct {
-	conf      *config.WebhookConfig
-	tmpl      *template.Template
-	logger    *slog.Logger
-	client    *http.Client
-	retrier   *notify.Retrier
-	templater alertmanagertypes.Templater
+	conf    *config.WebhookConfig
+	tmpl    *template.Template
+	logger  *slog.Logger
+	client  *http.Client
+	retrier *notify.Retrier
 }
 
 // New returns a new Webhook.
-func New(conf *config.WebhookConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
+func New(conf *config.WebhookConfig, t *template.Template, l *slog.Logger, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {
 	client, err := notify.NewClientWithTracing(*conf.HTTPConfig, Integration, httpOpts...)
 	if err != nil {
 		return nil, err
@@ -50,8 +48,7 @@ func New(conf *config.WebhookConfig, t *template.Template, l *slog.Logger, templ
 		client: client,
 		// Webhooks are assumed to respond with 2xx response codes on a successful
 		// request and 5xx response codes are assumed to be recoverable.
-		retrier:   &notify.Retrier{},
-		templater: templater,
+		retrier: &notify.Retrier{},
 	}, nil
 }
 

pkg/alertmanager/alertmanagernotify/webhook/webhook_test.go

@@ -9,7 +9,6 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -21,7 +20,6 @@ import (
 	"github.com/prometheus/common/promslog"
 	"github.com/stretchr/testify/require"
 
-	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/prometheus/alertmanager/config"
 	"github.com/prometheus/alertmanager/notify"
 	"github.com/prometheus/alertmanager/notify/test"
@@ -29,15 +27,13 @@ import (
 )
 
 func TestWebhookRetry(t *testing.T) {
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.WebhookConfig{
 			URL:        config.SecretTemplateURL("http://example.com"),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		alertmanagertemplate.New(tmpl, slog.Default()),
 	)
 	if err != nil {
 		require.NoError(t, err)
@@ -100,16 +96,13 @@ func TestWebhookRedactedURL(t *testing.T) {
 	defer fn()
 
 	secret := "secret"
-	tmpl := test.CreateTmpl(t)
-	templater := alertmanagertemplate.New(tmpl, slog.Default())
 	notifier, err := New(
 		&config.WebhookConfig{
 			URL:        config.SecretTemplateURL(u.String()),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		templater,
 	)
 	require.NoError(t, err)
 
@@ -125,15 +118,13 @@ func TestWebhookReadingURLFromFile(t *testing.T) {
 	_, err = f.WriteString(u.String() + "\n")
 	require.NoError(t, err, "writing to temp file failed")
 
-	tmpl := test.CreateTmpl(t)
 	notifier, err := New(
 		&config.WebhookConfig{
 			URLFile:    f.Name(),
 			HTTPConfig: &commoncfg.HTTPClientConfig{},
 		},
-		tmpl,
+		test.CreateTmpl(t),
 		promslog.NewNopLogger(),
-		alertmanagertemplate.New(tmpl, slog.Default()),
 	)
 	require.NoError(t, err)
 
@@ -187,15 +178,13 @@ func TestWebhookURLTemplating(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			calledURL = "" // Reset for each test
 
-			tmpl := test.CreateTmpl(t)
 			notifier, err := New(
 				&config.WebhookConfig{
 					URL:        config.SecretTemplateURL(tc.url),
 					HTTPConfig: &commoncfg.HTTPClientConfig{},
 				},
-				tmpl,
+				test.CreateTmpl(t),
 				promslog.NewNopLogger(),
-				alertmanagertemplate.New(tmpl, slog.Default()),
 			)
 			require.NoError(t, err)
 

pkg/alertmanager/alertmanagerserver/config.go

@@ -28,13 +28,6 @@ type Config struct {
 
 	// Configuration for the notification log.
 	NFLog NFLogConfig `mapstructure:"nflog"`
-
-	// Templates is the list of globs from which SigNoz's alertmanager notification
-	// templates are loaded (e.g. the email.signoz.html layout). This mirrors the
-	// upstream alertmanager `templates` config option (https://github.com/prometheus/alertmanager/blob/3b06b97af4d146e141af92885a185891eb79a5b0/config/config.go#L412).
-	// The upstream default templates (default.tmpl, email.tmpl) are always loaded
-	// from the embedded alertmanager assets, so only SigNoz's own templates are listed here.
-	Templates []string `mapstructure:"templates"`
 }
 
 type AlertsConfig struct {
@@ -107,6 +100,5 @@ func NewConfig() Config {
 			MaintenanceInterval: 15 * time.Minute,
 			Retention:           120 * time.Hour,
 		},
-		Templates: []string{"/root/templates/alertmanager/*.gotmpl"},
 	}
 }

pkg/alertmanager/alertmanagerserver/server.go

@@ -10,7 +10,6 @@ import (
 	"github.com/prometheus/alertmanager/types"
 	"golang.org/x/sync/errgroup"
 
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/prometheus/alertmanager/dispatch"
 	"github.com/prometheus/alertmanager/featurecontrol"
 	"github.com/prometheus/alertmanager/inhibit"
@@ -24,8 +23,8 @@ import (
 	"github.com/prometheus/common/model"
 
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify"
-	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager"
+	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 )
 
@@ -66,7 +65,6 @@ type Server struct {
 	muter               *MaintenanceMuter
 	marker              *types.MemMarker
 	tmpl                *template.Template
-	templater           alertmanagertypes.Templater
 	wg                  sync.WaitGroup
 	stopc               chan struct{}
 	notificationManager nfmanager.NotificationManager
@@ -244,21 +242,13 @@ func (server *Server) SetConfig(ctx context.Context, alertmanagerConfig *alertma
 	config := alertmanagerConfig.AlertmanagerConfig()
 
 	var err error
-	// Load SigNoz's alertmanager notification templates from the configured
-	// globs. The upstream default templates (default.tmpl, email.tmpl) are
-	// always loaded from the embedded alertmanager assets inside FromGlobs, so
-	// only SigNoz's own templates (e.g. the email.signoz.html layout) are listed
-	// here. The upstream config.Templates field is not used: SigNoz never
-	// populates it (there is no per-org template configuration).
-	server.tmpl, err = alertmanagertypes.FromGlobs(server.srvConfig.Templates)
+	server.tmpl, err = alertmanagertypes.FromGlobs(config.Templates)
 	if err != nil {
 		return err
 	}
 
 	server.tmpl.ExternalURL = server.srvConfig.ExternalURL
 
-	server.templater = alertmanagertemplate.New(server.tmpl, server.logger)
-
 	// Build the routing tree and record which receivers are used.
 	routes := dispatch.NewRoute(config.Route, nil)
 	activeReceivers := make(map[string]struct{})
@@ -275,7 +265,7 @@ func (server *Server) SetConfig(ctx context.Context, alertmanagerConfig *alertma
 			server.logger.InfoContext(ctx, "skipping creation of receiver not referenced by any route", slog.String("receiver", rcv.Name))
 			continue
 		}
-		integrations, err := alertmanagernotify.NewReceiverIntegrations(rcv, server.tmpl, server.logger, server.templater)
+		integrations, err := alertmanagernotify.NewReceiverIntegrations(rcv, server.tmpl, server.logger)
 		if err != nil {
 			return err
 		}
@@ -352,7 +342,7 @@ func (server *Server) SetConfig(ctx context.Context, alertmanagerConfig *alertma
 
 func (server *Server) TestReceiver(ctx context.Context, receiver alertmanagertypes.Receiver) error {
 	testAlert := alertmanagertypes.NewTestAlert(receiver, time.Now(), time.Now())
-	return alertmanagertypes.TestReceiver(ctx, receiver, alertmanagernotify.NewReceiverIntegrations, server.alertmanagerConfig, server.tmpl, server.logger, server.templater, testAlert.Labels, testAlert)
+	return alertmanagertypes.TestReceiver(ctx, receiver, alertmanagernotify.NewReceiverIntegrations, server.alertmanagerConfig, server.tmpl, server.logger, testAlert.Labels, testAlert)
 }
 
 func (server *Server) TestAlert(ctx context.Context, receiversMap map[*alertmanagertypes.PostableAlert][]string, config *alertmanagertypes.NotificationConfig) error {
@@ -435,7 +425,6 @@ func (server *Server) TestAlert(ctx context.Context, receiversMap map[*alertmana
 					server.alertmanagerConfig,
 					server.tmpl,
 					server.logger,
-					server.templater,
 					group.groupLabels,
 					group.alerts...,
 				)

pkg/alertmanager/alertmanagertemplate/alertmanagertemplate.go

@@ -15,6 +15,13 @@ import (
 	"github.com/prometheus/common/model"
 )
 
+// Templater expands user-authored title and body templates against a group
+// of alerts and returns channel-ready strings along with the aggregate data
+// a caller might reuse (e.g. to render an email layout around the body).
+type Templater interface {
+	Expand(ctx context.Context, req alertmanagertypes.ExpandRequest, alerts []*types.Alert) (*alertmanagertypes.ExpandResult, error)
+}
+
 type templater struct {
 	tmpl   *template.Template
 	logger *slog.Logger
@@ -22,7 +29,7 @@ type templater struct {
 
 // New returns a Templater bound to the given Prometheus alertmanager
 // template and logger.
-func New(tmpl *template.Template, logger *slog.Logger) alertmanagertypes.Templater {
+func New(tmpl *template.Template, logger *slog.Logger) Templater {
 	return &templater{tmpl: tmpl, logger: logger}
 }
 
@@ -130,9 +137,6 @@ func (at *templater) expandTitle(
 }
 
 // expandBody expands the body template for each individual alert. Returns nil if the template is empty.
-// Non-nil results are positionally aligned with ntd.Alerts: sb[i] corresponds to alerts[i], and
-// entries for alerts whose template expands to empty are kept as "" so callers can index per-alert
-// metadata (related links, firing/resolved color) by the same index.
 func (at *templater) expandBody(
 	bodyTemplate string,
 	ntd *alertmanagertypes.NotificationTemplateData,
@@ -140,7 +144,7 @@ func (at *templater) expandBody(
 	if bodyTemplate == "" {
 		return nil, nil, nil
 	}
-	sb := make([]string, len(ntd.Alerts))
+	var sb []string
 	missingVars := make(map[string]bool)
 	for i := range ntd.Alerts {
 		processRes, err := preProcessTemplateAndData(bodyTemplate, &ntd.Alerts[i])
@@ -151,10 +155,13 @@ func (at *templater) expandBody(
 		if err != nil {
 			return nil, nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to execute custom body template: %s", err.Error())
 		}
+		// add unknown variables and templated text to the result
 		for k := range processRes.UnknownVars {
 			missingVars[k] = true
 		}
-		sb[i] = strings.TrimSpace(part)
+		if strings.TrimSpace(part) != "" {
+			sb = append(sb, strings.TrimSpace(part))
+		}
 	}
 	return sb, missingVars, nil
 }
@@ -182,20 +189,17 @@ func (at *templater) buildNotificationTemplateData(
 		externalURL = at.tmpl.ExternalURL.String()
 	}
 
-	// Raw (including private `_*`) kv first so buildRuleInfo can read the
-	// private rule annotations. The filtered copies are what ends up
-	// on the template-visible surfaces.
-	rawCommonAnnotations := extractCommonKV(alerts, func(a *types.Alert) model.LabelSet { return a.Annotations })
+	commonAnnotations := extractCommonKV(alerts, func(a *types.Alert) model.LabelSet { return a.Annotations })
 	commonLabels := extractCommonKV(alerts, func(a *types.Alert) model.LabelSet { return a.Labels })
 
 	// aggregate labels and annotations from all alerts
 	labels := aggregateKV(alerts, func(a *types.Alert) model.LabelSet { return a.Labels })
 	annotations := aggregateKV(alerts, func(a *types.Alert) model.LabelSet { return a.Annotations })
 
-	// Strip private annotations from template-visible surfaces; the structured
-	// fields on AlertInfo/RuleInfo already hold anything a template needs from
-	// them.
-	commonAnnotations := alertmanagertypes.FilterPublicAnnotations(rawCommonAnnotations)
+	// Strip private annotations from surfaces visible to templates or
+	// notifications; the structured fields on AlertInfo/RuleInfo already hold
+	// anything a template needs from them.
+	commonAnnotations = alertmanagertypes.FilterPublicAnnotations(commonAnnotations)
 	annotations = alertmanagertypes.FilterPublicAnnotations(annotations)
 
 	// build the alert data slice
@@ -229,7 +233,7 @@ func (at *templater) buildNotificationTemplateData(
 			TotalFiring:   firing,
 			TotalResolved: resolved,
 		},
-		Rule:              buildRuleInfo(commonLabels, rawCommonAnnotations),
+		Rule:              buildRuleInfo(commonLabels, commonAnnotations),
 		GroupLabels:       gl,
 		CommonLabels:      commonLabels,
 		CommonAnnotations: commonAnnotations,

pkg/alertmanager/alertmanagertemplate/alertmanagertemplate_test.go

@@ -19,7 +19,7 @@ import (
 
 // testSetup returns an AlertTemplater and a context pre-populated with group key,
 // receiver name, and group labels for use in tests.
-func testSetup(t *testing.T) (alertmanagertypes.Templater, context.Context) {
+func testSetup(t *testing.T) (Templater, context.Context) {
 	t.Helper()
 	tmpl := test.CreateTmpl(t)
 	ctx := context.Background()

pkg/apiserver/signozapiserver/tracedetail.go

@@ -29,42 +29,5 @@ func (provider *provider) addTraceDetailRoutes(router *mux.Router) error {
 		return err
 	}
 
-	if err := router.Handle("/api/v4/traces/{traceID}/waterfall", handler.New(
-		provider.authzMiddleware.ViewAccess(provider.traceDetailHandler.GetWaterfallV4),
-		handler.OpenAPIDef{
-			ID:                  "GetWaterfallV4",
-			Tags:                []string{"tracedetail"},
-			Summary:             "Get waterfall view for a trace",
-			Description:         "Returns the waterfall view of spans including all spans if total spans are under a limit, a max count otherwise. Aggregations are dropped compared to v3",
-			Request:             new(spantypes.PostableWaterfall),
-			RequestContentType:  "application/json",
-			Response:            new(spantypes.GettableWaterfallTrace),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v3/traces/{traceID}/flamegraph", handler.New(
-		provider.authzMiddleware.ViewAccess(provider.traceDetailHandler.GetFlamegraph),
-		handler.OpenAPIDef{
-			ID:                  "GetFlamegraph",
-			Tags:                []string{"tracedetail"},
-			Summary:             "Get flamegraph view for a trace",
-			Description:         "Returns the flamegraph view of spans for a given trace ID.",
-			Request:             new(spantypes.PostableFlamegraph),
-			RequestContentType:  "application/json",
-			Response:            new(spantypes.GettableFlamegraphTrace),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
 	return nil
 }

pkg/emailing/config.go

@@ -65,7 +65,7 @@ func newConfig() factory.Config {
 	return &Config{
 		Enabled: false,
 		Templates: Templates{
-			Directory: "/root/templates/email",
+			Directory: "/root/templates",
 			Format: Format{
 				Header: Header{
 					Enabled: false,

pkg/modules/dashboard/dashboard.go

@@ -41,6 +41,8 @@ type Module interface {
 	List(ctx context.Context, orgID valuer.UUID) ([]*dashboardtypes.Dashboard, error)
 
 	Update(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, data dashboardtypes.UpdatableDashboard, diff int) (*dashboardtypes.Dashboard, error)
+	
+	ResetSystemDashboard(ctx context.Context, orgID valuer.UUID, updatedBy string) (*dashboardtypes.Dashboard, error)
 
 	LockUnlock(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error
 
@@ -74,4 +76,6 @@ type Handler interface {
 	LockUnlock(http.ResponseWriter, *http.Request)
 
 	Delete(http.ResponseWriter, *http.Request)
+
+	ResetSystemDashboard(http.ResponseWriter, *http.Request)
 }

pkg/modules/dashboard/impldashboard/handler.go

@@ -185,6 +185,32 @@ func (handler *handler) LockUnlock(rw http.ResponseWriter, r *http.Request) {
 
 }
 
+// ResetSystemDashboard resets the org's system dashboard to its default.
+func (handler *handler) ResetSystemDashboard(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	dashboard, err := handler.module.ResetSystemDashboard(ctx, orgID, claims.Email)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, dashboard)
+}
+
 func (handler *handler) Delete(rw http.ResponseWriter, r *http.Request) {
 	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
 	defer cancel()

pkg/modules/dashboard/impldashboard/module.go

@@ -66,6 +66,15 @@ func (module *module) Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID
 	return dashboardtypes.NewDashboardFromStorableDashboard(storableDashboard), nil
 }
 
+func (module *module) GetSystemDashboard(ctx context.Context, orgID valuer.UUID) (*dashboardtypes.Dashboard, error) {
+	storableDashboard, err := module.store.GetSystemDashboard(ctx, orgID)
+	if err != nil {
+		return nil, err
+	}
+
+	return dashboardtypes.NewDashboardFromStorableDashboard(storableDashboard), nil
+}
+
 func (module *module) List(ctx context.Context, orgID valuer.UUID) ([]*dashboardtypes.Dashboard, error) {
 	storableDashboards, err := module.store.List(ctx, orgID)
 	if err != nil {
@@ -94,8 +103,7 @@ func (module *module) Update(ctx context.Context, orgID valuer.UUID, id valuer.U
 		return nil, err
 	}
 
-	err = dashboard.Update(ctx, updatableDashboard, updatedBy, diff)
-	if err != nil {
+	if err := dashboard.Update(ctx, updatableDashboard, updatedBy, diff); err != nil {
 		return nil, err
 	}
 
@@ -104,14 +112,32 @@ func (module *module) Update(ctx context.Context, orgID valuer.UUID, id valuer.U
 		return nil, err
 	}
 
-	err = module.store.Update(ctx, orgID, storableDashboard)
-	if err != nil {
+	if err := module.store.Update(ctx, orgID, storableDashboard); err != nil {
 		return nil, err
 	}
 
 	return dashboard, nil
 }
 
+func (module *module) ResetSystemDashboard(ctx context.Context, orgID valuer.UUID, updatedBy string) (*dashboardtypes.Dashboard, error) {
+	existing, err := module.GetSystemDashboard(ctx, orgID)
+	if err != nil {
+		return nil, err
+	}
+
+	defaults, err := dashboardtypes.NewDefaultSystemDashboard(orgID)
+	if err != nil {
+		return nil, err
+	}
+
+	existingID, err := valuer.NewUUID(existing.ID)
+	if err != nil {
+		return nil, err
+	}
+
+	return module.Update(ctx, orgID, existingID, updatedBy, defaults.Data, 0)
+}
+
 func (module *module) LockUnlock(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error {
 	dashboard, err := module.Get(ctx, orgID, id)
 	if err != nil {
@@ -153,8 +179,7 @@ func (module *module) Delete(ctx context.Context, orgID valuer.UUID, id valuer.U
 		return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "dashboard is locked, please unlock the dashboard to be delete it")
 	}
 
-	err = module.store.Delete(ctx, orgID, id)
-	if err != nil {
+	if err := module.store.Delete(ctx, orgID, id); err != nil {
 		return err
 	}
 

pkg/modules/dashboard/impldashboard/store.go

@@ -63,6 +63,23 @@ func (store *store) Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID)
 	return storableDashboard, nil
 }
 
+func (store *store) GetSystemDashboard(ctx context.Context, orgID valuer.UUID) (*dashboardtypes.StorableDashboard, error) {
+	storableDashboard := new(dashboardtypes.StorableDashboard)
+	err := store.
+		sqlstore.
+		BunDBCtx(ctx).
+		NewSelect().
+		Model(storableDashboard).
+		Where("org_id = ?", orgID).
+		Where("source = ?", dashboardtypes.SourceSystem.StringValue()).
+		Limit(1).
+		Scan(ctx)
+	if err != nil {
+		return nil, store.sqlstore.WrapNotFoundErrf(err, errors.CodeNotFound, "system dashboard doesn't exist")
+	}
+	return storableDashboard, nil
+}
+
 func (store *store) GetPublic(ctx context.Context, dashboardID string) (*dashboardtypes.StorablePublicDashboard, error) {
 	storable := new(dashboardtypes.StorablePublicDashboard)
 	err := store.
@@ -153,7 +170,7 @@ func (store *store) ListPublic(ctx context.Context, orgID valuer.UUID) ([]*dashb
 func (store *store) Update(ctx context.Context, orgID valuer.UUID, storableDashboard *dashboardtypes.StorableDashboard) error {
 	_, err := store.
 		sqlstore.
-		BunDB().
+		BunDBCtx(ctx).
 		NewUpdate().
 		Model(storableDashboard).
 		WherePK().

pkg/modules/tracedetail/config.go

@@ -6,16 +6,7 @@ import (
 )
 
 type Config struct {
-	Waterfall  WaterfallConfig  `mapstructure:"waterfall"`
-	Flamegraph FlamegraphConfig `mapstructure:"flamegraph"`
-}
-
-type FlamegraphConfig struct {
-	MaxSelectedLevels            int  `mapstructure:"max_selected_levels"`
-	MaxSpansPerLevel             int  `mapstructure:"max_spans_per_level"`
-	SamplingTopLatencySpansCount int  `mapstructure:"sampling_top_latency_count"`
-	SamplingBucketCount          int  `mapstructure:"sampling_bucket_count"`
-	SelectAllSpansLimit          uint `mapstructure:"select_all_spans_limit"`
+	Waterfall WaterfallConfig `mapstructure:"waterfall"`
 }
 
 type WaterfallConfig struct {
@@ -38,13 +29,6 @@ func newConfig() factory.Config {
 			MaxDepthToAutoExpand:     5,
 			MaxLimitToSelectAllSpans: 10_000,
 		},
-		Flamegraph: FlamegraphConfig{
-			MaxSelectedLevels:            50,
-			MaxSpansPerLevel:             100,
-			SamplingTopLatencySpansCount: 5,
-			SamplingBucketCount:          50,
-			SelectAllSpansLimit:          100_000,
-		},
 	}
 }
 
@@ -61,25 +45,5 @@ func (c Config) Validate() error {
 		return errors.NewInvalidInputf(errors.CodeInvalidInput,
 			"tracedetail.waterfall.max_limit_to_select_all_spans must be positive")
 	}
-	if c.Flamegraph.MaxSelectedLevels <= 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"tracedetail.flamegraph.level_limit must be positive, got %d", c.Flamegraph.MaxSelectedLevels)
-	}
-	if c.Flamegraph.MaxSpansPerLevel <= 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"tracedetail.flamegraph.spans_per_level must be positive, got %d", c.Flamegraph.MaxSpansPerLevel)
-	}
-	if c.Flamegraph.SamplingTopLatencySpansCount < 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"tracedetail.flamegraph.top_latency_count cannot be negative, got %d", c.Flamegraph.SamplingTopLatencySpansCount)
-	}
-	if c.Flamegraph.SamplingBucketCount <= 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"tracedetail.flamegraph.bucket_count must be positive, got %d", c.Flamegraph.SamplingBucketCount)
-	}
-	if c.Flamegraph.SelectAllSpansLimit == 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput,
-			"tracedetail.flamegraph.max_limit_to_select_all_spans must be positive")
-	}
 	return nil
 }

pkg/modules/tracedetail/impltracedetail/handler.go

@@ -38,40 +38,3 @@ func (h *handler) GetWaterfall(rw http.ResponseWriter, r *http.Request) {
 
 	render.Success(rw, http.StatusOK, result)
 }
-
-func (h *handler) GetWaterfallV4(rw http.ResponseWriter, r *http.Request) {
-	req := new(spantypes.PostableWaterfall)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := req.Validate(); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	result, err := h.module.GetWaterfallV4(r.Context(), mux.Vars(r)["traceID"], req.SelectedSpanID, req.UncollapsedSpans, req.Limit)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, result)
-}
-
-func (h *handler) GetFlamegraph(rw http.ResponseWriter, r *http.Request) {
-	req := new(spantypes.PostableFlamegraph)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	result, err := h.module.GetFlamegraph(r.Context(), mux.Vars(r)["traceID"], req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, result)
-}

pkg/modules/tracedetail/impltracedetail/module.go

@@ -2,7 +2,6 @@ package impltracedetail
 
 import (
 	"context"
-	"time"
 
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/modules/tracedetail"
@@ -46,7 +45,7 @@ func (m *module) GetWaterfall(ctx context.Context, traceID string, req *spantype
 	return spantypes.NewGettableWaterfallTrace(waterfallTrace, selectedSpans, uncollapsedSpans, selectedAllSpans, aggregationResults), nil
 }
 
-// getTraceData fetches all spans for a trace and builds the WaterfallTrace.
+// getTraceData returns the waterfall cache for the given traceID with fallback on DB.
 func (m *module) getTraceData(ctx context.Context, traceID string) (*spantypes.WaterfallTrace, error) {
 	summary, err := m.store.GetTraceSummary(ctx, traceID)
 	if err != nil {
@@ -62,144 +61,6 @@ func (m *module) getTraceData(ctx context.Context, traceID string) (*spantypes.W
 		return nil, spantypes.ErrTraceNotFound
 	}
 
-	nodes := make([]*spantypes.WaterfallSpan, len(spanItems))
-	for i := range spanItems {
-		nodes[i] = spanItems[i].ToWaterfallSpan(traceID)
-	}
-	return spantypes.NewWaterfallTraceFromSpans(nodes), nil
-}
-
-// GetWaterfallV4 is the OOM-safe V4 waterfall.
-// For large traces (NumSpans > effectiveLimit) it uses a two-step fetch:
-// minimal fields for all spans to build the tree, then full fields for the
-// visible window only. Aggregations are not returned.
-func (m *module) GetWaterfallV4(ctx context.Context, traceID string, selectedSpanID string, uncollapsedSpans []string, selectAllLimit uint) (*spantypes.GettableWaterfallTrace, error) {
-	summary, err := m.store.GetTraceSummary(ctx, traceID)
-	if err != nil {
-		return nil, err
-	}
-	effectiveLimit := min(selectAllLimit, m.config.Waterfall.MaxLimitToSelectAllSpans)
-	if summary.NumSpans > uint64(effectiveLimit) {
-		return m.getWindowedWaterfall(ctx, traceID, selectedSpanID, uncollapsedSpans, summary.Start, summary.End)
-	}
-	return m.getFullWaterfall(ctx, traceID, summary)
-}
-
-func (m *module) getFullWaterfall(ctx context.Context, traceID string, summary *spantypes.TraceSummary) (*spantypes.GettableWaterfallTrace, error) {
-	spanItems, err := m.store.GetTraceSpans(ctx, traceID, summary)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(spanItems) == 0 {
-		return nil, spantypes.ErrTraceNotFound
-	}
-
-	nodes := make([]*spantypes.WaterfallSpan, len(spanItems))
-	for i := range spanItems {
-		nodes[i] = spanItems[i].ToWaterfallSpan(traceID)
-	}
-	waterfallTrace := spantypes.NewWaterfallTraceFromSpans(nodes)
-	selectedSpans := waterfallTrace.GetAllSpans()
-
-	return spantypes.NewGettableWaterfallTrace(waterfallTrace, selectedSpans, nil, true, nil), nil
-}
-
-func (m *module) GetFlamegraph(ctx context.Context, traceID string, req *spantypes.PostableFlamegraph) (*spantypes.GettableFlamegraphTrace, error) {
-	summary, err := m.store.GetTraceSummary(ctx, traceID)
-	if err != nil {
-		return nil, err
-	}
-	if summary.NumSpans <= uint64(m.config.Flamegraph.SelectAllSpansLimit) {
-		return m.getFullFlamegraph(ctx, traceID, summary)
-	}
-	return m.getWindowedFlamegraph(ctx, traceID, req.SelectedSpanID, summary)
-}
-
-func (m *module) getFullFlamegraph(ctx context.Context, traceID string, summary *spantypes.TraceSummary) (*spantypes.GettableFlamegraphTrace, error) {
-	fullSpans, err := m.store.GetTraceSpans(ctx, traceID, summary)
-	if err != nil {
-		return nil, err
-	}
-	if len(fullSpans) == 0 {
-		return nil, spantypes.ErrTraceNotFound
-	}
-	flamegraphTrace := spantypes.NewFlamegraphTraceFromStorable(fullSpans)
-	return spantypes.NewGettableFlamegraphTrace(
-		flamegraphTrace.GetAllLevels(),
-		summary.Start.UnixMilli(), summary.End.UnixMilli(), false,
-	), nil
-}
-
-// getWindowedFlamegraph returns a window of a max levels and max sampled spans per level around the selected span
-func (m *module) getWindowedFlamegraph(ctx context.Context, traceID, selectedSpanID string, summary *spantypes.TraceSummary) (*spantypes.GettableFlamegraphTrace, error) {
-	minimalSpans, err := m.store.GetMinimalSpans(ctx, traceID, summary.Start, summary.End)
-	if err != nil {
-		return nil, err
-	}
-	if len(minimalSpans) == 0 {
-		return nil, spantypes.ErrTraceNotFound
-	}
-
-	flamegraphTrace := spantypes.NewFlamegraphTraceFromMinimal(minimalSpans)
-	minimalSpans = nil
-
-	cfg := m.config.Flamegraph
-	selectedSpans := flamegraphTrace.GetSelectedLevels(selectedSpanID,
-		cfg.MaxSelectedLevels, cfg.MaxSpansPerLevel, cfg.SamplingTopLatencySpansCount, cfg.SamplingBucketCount)
-	if len(selectedSpans) == 0 {
-		return nil, spantypes.ErrTraceNotFound
-	}
-
-	fullSpans, err := m.store.GetTraceSpansByIDs(ctx, traceID, summary.Start, summary.End,
-		spantypes.FlamegraphWindowSpanIDs(selectedSpans))
-	if err != nil {
-		return nil, err
-	}
-
-	return spantypes.NewGettableFlamegraphTrace(
-		flamegraphTrace.EnrichSelectedSpans(selectedSpans, fullSpans),
-		summary.Start.UnixMilli(), summary.End.UnixMilli(), true,
-	), nil
-}
-
-// getWindowedWaterfall builds the waterfall tree with minimal data and then returns only a window of full spans.
-func (m *module) getWindowedWaterfall(ctx context.Context, traceID, selectedSpanID string, uncollapsedSpans []string, start, end time.Time) (*spantypes.GettableWaterfallTrace, error) {
-	// Step 1: minimal fetch → build full tree → select visible window
-	minimalSpans, err := m.store.GetMinimalSpans(ctx, traceID, start, end)
-	if err != nil {
-		return nil, err
-	}
-	if len(minimalSpans) == 0 {
-		return nil, spantypes.ErrTraceNotFound
-	}
-
-	nodes := make([]*spantypes.WaterfallSpan, len(minimalSpans))
-	for i := range minimalSpans {
-		nodes[i] = minimalSpans[i].ToWaterfallSpan(traceID)
-	}
-	waterfallTrace := spantypes.NewWaterfallTraceFromSpans(nodes)
-
-	selectedSpans, uncollapsedSpans := waterfallTrace.GetSelectedSpans(
-		uncollapsedSpans,
-		selectedSpanID,
-		m.config.Waterfall.SpanPageSize,
-		m.config.Waterfall.MaxDepthToAutoExpand,
-	)
-
-	// Step 2: full fetch for the selected window only
-	spanIDs := make([]string, len(selectedSpans))
-	for i, s := range selectedSpans {
-		spanIDs[i] = s.SpanID
-	}
-	fullSpans, err := m.store.GetTraceSpansByIDs(ctx, traceID, start, end, spanIDs)
-	if err != nil {
-		return nil, err
-	}
-
-	spantypes.EnrichSelectedSpans(selectedSpans, fullSpans)
-
-	return spantypes.NewGettableWaterfallTrace(
-		waterfallTrace, selectedSpans, uncollapsedSpans, false, nil,
-	), nil
+	traceData := spantypes.NewWaterfallTraceFromSpans(spanItems)
+	return traceData, nil
 }

pkg/modules/tracedetail/impltracedetail/store.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"database/sql"
 	"fmt"
-	"time"
 
 	sqlbuilder "github.com/huandu/go-sqlbuilder"
 
@@ -13,8 +12,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/spantypes"
 )
 
-const colServiceName = `resource_string_service$$$$name` // $ gets escaped so $$$$ converts to $$.
-
 type traceStore struct {
 	telemetryStore telemetrystore.TelemetryStore
 }
@@ -48,8 +45,8 @@ func (s *traceStore) GetTraceSpans(ctx context.Context, traceID string, summary
 	// DISTINCT ON (span_id) is ClickHouse-specific syntax not supported by sqlbuilder
 	query := fmt.Sprintf(`
 		SELECT DISTINCT ON (span_id)
-			timestamp, duration_nano, span_id, has_error, kind,
-			resource_string_service$$name, name,
+			timestamp, duration_nano, span_id, trace_id, has_error, kind,
+			resource_string_service$$name, name, links as references,
 			attributes_string, attributes_number, attributes_bool, resources_string,
 			events, status_message, status_code_string, kind_string, parent_span_id,
 			flags, is_remote, trace_state, status_code,
@@ -72,64 +69,3 @@ func (s *traceStore) GetTraceSpans(ctx context.Context, traceID string, summary
 	}
 	return spanItems, nil
 }
-
-func (s *traceStore) GetMinimalSpans(ctx context.Context, traceID string, start, end time.Time) ([]spantypes.MinimalSpan, error) {
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select(
-		"DISTINCT ON (span_id) span_id",
-		"parent_span_id", "timestamp", "duration_nano", "has_error",
-		colServiceName,
-	)
-	sb.From(fmt.Sprintf("%s.%s", spantypes.TraceDB, spantypes.TraceTable))
-	sb.Where(
-		sb.E("trace_id", traceID),
-		sb.GE("ts_bucket_start", start.Unix()-1800),
-		sb.LE("ts_bucket_start", end.Unix()),
-	)
-	sb.OrderByAsc("timestamp")
-	sb.OrderByAsc("name")
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-
-	var spans []spantypes.MinimalSpan
-	if err := s.telemetryStore.ClickhouseDB().Select(ctx, &spans, query, args...); err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "error querying minimal spans")
-	}
-	return spans, nil
-}
-
-func (s *traceStore) GetTraceSpansByIDs(ctx context.Context, traceID string, start, end time.Time, spanIDs []string) ([]spantypes.StorableSpan, error) {
-	if len(spanIDs) == 0 {
-		return []spantypes.StorableSpan{}, nil
-	}
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select(
-		"DISTINCT ON (span_id) timestamp",
-		"duration_nano", "span_id", "has_error", "kind",
-		colServiceName, "name",
-		"attributes_string", "attributes_number", "attributes_bool", "resources_string",
-		"events", "status_message", "status_code_string", "kind_string", "parent_span_id",
-		"flags", "is_remote", "trace_state", "status_code",
-		"db_name", "db_operation", "http_method", "http_url", "http_host",
-		"external_http_method", "external_http_url", "response_status_code",
-	)
-	sb.From(fmt.Sprintf("%s.%s", spantypes.TraceDB, spantypes.TraceTable))
-	ids := make([]any, len(spanIDs))
-	for i, id := range spanIDs {
-		ids[i] = id
-	}
-	sb.Where(
-		sb.E("trace_id", traceID),
-		sb.In("span_id", ids...),
-		sb.GE("ts_bucket_start", start.Unix()-1800),
-		sb.LE("ts_bucket_start", end.Unix()),
-	)
-	sb.OrderByAsc("timestamp")
-	sb.OrderByAsc("name")
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-
-	var spans []spantypes.StorableSpan
-	if err := s.telemetryStore.ClickhouseDB().Select(ctx, &spans, query, args...); err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "error querying trace spans by IDs")
-	}
-	return spans, nil
-}

pkg/modules/tracedetail/tracedetail.go

@@ -10,13 +10,9 @@ import (
 // Handler exposes HTTP handlers for trace detail APIs.
 type Handler interface {
 	GetWaterfall(http.ResponseWriter, *http.Request)
-	GetWaterfallV4(http.ResponseWriter, *http.Request)
-	GetFlamegraph(http.ResponseWriter, *http.Request)
 }
 
 // Module defines the business logic for trace detail operations.
 type Module interface {
 	GetWaterfall(ctx context.Context, traceID string, req *spantypes.PostableWaterfall) (*spantypes.GettableWaterfallTrace, error)
-	GetWaterfallV4(ctx context.Context, traceID string, selectedSpanID string, uncollapsedSpans []string, selectAllLimit uint) (*spantypes.GettableWaterfallTrace, error)
-	GetFlamegraph(ctx context.Context, traceID string, req *spantypes.PostableFlamegraph) (*spantypes.GettableFlamegraphTrace, error)
 }

pkg/modules/user/impluser/setter.go

@@ -3,6 +3,7 @@ package impluser
 import (
 	"context"
 	"log/slog"
+	"slices"
 	"strings"
 	"time"
 
@@ -20,6 +21,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/types/coretypes"
 	"github.com/SigNoz/signoz/pkg/types/emailtypes"
+	"github.com/SigNoz/signoz/pkg/types/integrationtypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
@@ -369,6 +371,10 @@ func (module *setter) DeleteUser(ctx context.Context, orgID valuer.UUID, id stri
 		return errors.WithAdditionalf(err, "cannot delete already deleted user")
 	}
 
+	if slices.Contains(integrationtypes.AllIntegrationUserEmails, integrationtypes.IntegrationUserEmail(user.Email.String())) {
+		return errors.New(errors.TypeForbidden, errors.CodeForbidden, "integration user cannot be deleted")
+	}
+
 	deleter, err := module.store.GetUser(ctx, valuer.MustNewUUID(deletedBy))
 	if err != nil {
 		return err

pkg/querier/builder_query.go

@@ -19,8 +19,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
 
-const traceOutsideRangeWarn = "Query %s references a trace_id that exists between %s and %s (UTC) but lies outside the selected time range; adjust the time range to see results"
-
 type builderQuery[T any] struct {
 	logger         *slog.Logger
 	telemetryStore telemetrystore.TelemetryStore
@@ -201,21 +199,7 @@ func (q *builderQuery[T]) Execute(ctx context.Context) (*qbtypes.Result, error)
 		return q.executeWindowList(ctx)
 	}
 
-	fromMS, toMS := q.fromMS, q.toMS
-	if q.spec.Signal == telemetrytypes.SignalTraces || q.spec.Signal == telemetrytypes.SignalLogs {
-		var overlap bool
-		var warning string
-		fromMS, toMS, overlap, warning = q.narrowWindowByTraceID(ctx, fromMS, toMS)
-		if !overlap {
-			res := emptyResultFor(q.kind, q.spec.Name)
-			if warning != "" {
-				res.Warnings = []string{warning}
-			}
-			return res, nil
-		}
-	}
-
-	stmt, err := q.stmtBuilder.Build(ctx, fromMS, toMS, q.kind, q.spec, q.variables)
+	stmt, err := q.stmtBuilder.Build(ctx, q.fromMS, q.toMS, q.kind, q.spec, q.variables)
 	if err != nil {
 		return nil, err
 	}
@@ -231,88 +215,6 @@ func (q *builderQuery[T]) Execute(ctx context.Context) (*qbtypes.Result, error)
 	return result, nil
 }
 
-// narrowWindowByTraceID inspects the filter for trace_id predicates and clamps
-// [fromMS,toMS] to the time range stored in signoz_traces.distributed_trace_summary.
-// Returns the (possibly narrowed) window, overlap=false when the trace lies
-// completely outside the query window (callers should short-circuit), and a
-// warning string the caller should attach to the empty result when the trace
-// exists but is outside the selected window.
-//
-// When the trace_id is not present in trace_summary the behaviour differs by
-// signal:
-//   - traces: trace_summary is derived from the spans table, so a missing row
-//     means no spans exist for that trace_id; we short-circuit to empty.
-//   - logs: logs can carry a trace_id even when traces are not ingested at all
-//     (e.g. traces disabled). We must not short-circuit; instead leave the
-//     window untouched and let the query run.
-func (q *builderQuery[T]) narrowWindowByTraceID(ctx context.Context, fromMS, toMS uint64) (uint64, uint64, bool, string) {
-	if q.spec.Filter == nil || q.spec.Filter.Expression == "" {
-		return fromMS, toMS, true, ""
-	}
-
-	traceIDs, found := telemetrytraces.ExtractTraceIDsFromFilter(q.spec.Filter.Expression)
-	if !found || len(traceIDs) == 0 {
-		return fromMS, toMS, true, ""
-	}
-
-	finder := telemetrytraces.NewTraceTimeRangeFinder(q.telemetryStore)
-	traceStart, traceEnd, exists, err := finder.GetTraceTimeRangeMulti(ctx, traceIDs)
-	if err != nil {
-		return fromMS, toMS, true, ""
-	}
-	if !exists {
-		if q.spec.Signal == telemetrytypes.SignalTraces {
-			q.logger.DebugContext(ctx, "trace_id not found in trace_summary; short-circuiting traces query to empty",
-				slog.Any("trace_ids", traceIDs))
-			return fromMS, toMS, false, ""
-		}
-		q.logger.DebugContext(ctx, "trace_id not found in trace_summary; leaving time range untouched for logs",
-			slog.Any("trace_ids", traceIDs))
-		return fromMS, toMS, true, ""
-	}
-
-	traceStartMS := uint64(traceStart) / 1_000_000
-	traceEndMS := uint64(traceEnd) / 1_000_000
-	if traceStartMS == 0 || traceEndMS == 0 {
-		return fromMS, toMS, true, ""
-	}
-
-	if traceStartMS > toMS || traceEndMS < fromMS {
-		traceStartUTC := time.UnixMilli(int64(traceStartMS)).UTC().Format(time.RFC3339)
-		traceEndUTC := time.UnixMilli(int64(traceEndMS)).UTC().Format(time.RFC3339)
-		return fromMS, toMS, false, fmt.Sprintf(traceOutsideRangeWarn, q.spec.Name, traceStartUTC, traceEndUTC)
-	}
-	if traceStartMS > fromMS {
-		fromMS = traceStartMS
-	}
-	if traceEndMS < toMS {
-		toMS = traceEndMS
-	}
-	q.logger.DebugContext(ctx, "optimized time range using trace_id lookup",
-		slog.String("signal", q.spec.Signal.StringValue()),
-		slog.Any("trace_ids", traceIDs),
-		slog.Uint64("start", fromMS),
-		slog.Uint64("end", toMS))
-	return fromMS, toMS, true, ""
-}
-
-// emptyResultFor returns an empty result payload appropriate for the given kind.
-func emptyResultFor(kind qbtypes.RequestType, queryName string) *qbtypes.Result {
-	var value any
-	switch kind {
-	case qbtypes.RequestTypeTimeSeries:
-		value = &qbtypes.TimeSeriesData{QueryName: queryName}
-	case qbtypes.RequestTypeScalar:
-		value = &qbtypes.ScalarData{QueryName: queryName}
-	default:
-		value = &qbtypes.RawData{QueryName: queryName}
-	}
-	return &qbtypes.Result{
-		Type:  kind,
-		Value: value,
-	}
-}
-
 // executeWithContext executes the query with query window and step context for partial value detection.
 func (q *builderQuery[T]) executeWithContext(ctx context.Context, query string, args []any) (*qbtypes.Result, error) {
 	ctx = ctxtypes.NewContextWithCommentVals(ctx, map[string]string{
@@ -408,27 +310,42 @@ func (q *builderQuery[T]) executeWindowList(ctx context.Context) (*qbtypes.Resul
 	totalBytes := uint64(0)
 	start := time.Now()
 
-	// Check if filter contains trace_id(s) and optimize time range if needed.
-	// Applies to both traces (the listing this branch was built for) and logs
-	// (which carry trace_id and benefit from the same clamp before bucketing).
-	if q.spec.Signal == telemetrytypes.SignalTraces || q.spec.Signal == telemetrytypes.SignalLogs {
-		var overlap bool
-		var warning string
-		fromMS, toMS, overlap, warning = q.narrowWindowByTraceID(ctx, fromMS, toMS)
-		if !overlap {
-			res := &qbtypes.Result{
-				Type: qbtypes.RequestTypeRaw,
-				Value: &qbtypes.RawData{
-					QueryName: q.spec.Name,
-				},
-				Stats: qbtypes.ExecStats{
-					DurationMS: uint64(time.Since(start).Milliseconds()),
-				},
+	// Check if filter contains trace_id(s) and optimize time range if needed
+	if q.spec.Signal == telemetrytypes.SignalTraces &&
+		q.spec.Filter != nil && q.spec.Filter.Expression != "" {
+
+		traceIDs, found := telemetrytraces.ExtractTraceIDsFromFilter(q.spec.Filter.Expression)
+		if found && len(traceIDs) > 0 {
+			finder := telemetrytraces.NewTraceTimeRangeFinder(q.telemetryStore)
+
+			traceStart, traceEnd, ok := finder.GetTraceTimeRangeMulti(ctx, traceIDs)
+			traceStartMS := uint64(traceStart) / 1_000_000
+			traceEndMS := uint64(traceEnd) / 1_000_000
+			if !ok {
+				q.logger.DebugContext(ctx, "failed to get trace time range", slog.Any("trace_ids", traceIDs))
+			} else if traceStartMS > 0 && traceEndMS > 0 {
+				// no overlap — nothing to return
+				if uint64(traceStartMS) > toMS || uint64(traceEndMS) < fromMS {
+					return &qbtypes.Result{
+						Type: qbtypes.RequestTypeRaw,
+						Value: &qbtypes.RawData{
+							QueryName: q.spec.Name,
+						},
+						Stats: qbtypes.ExecStats{
+							DurationMS: uint64(time.Since(start).Milliseconds()),
+						},
+					}, nil
+				}
+
+				// clamp window to trace time range before bucketing
+				if uint64(traceStartMS) > fromMS {
+					fromMS = uint64(traceStartMS)
+				}
+				if uint64(traceEndMS) < toMS {
+					toMS = uint64(traceEndMS)
+				}
+				q.logger.DebugContext(ctx, "optimized time range for traces", slog.Any("trace_ids", traceIDs), slog.Uint64("start", fromMS), slog.Uint64("end", toMS))
 			}
-			if warning != "" {
-				res.Warnings = []string{warning}
-			}
-			return res, nil
 		}
 	}
 

pkg/query-service/app/cloudintegrations/Readme.md

@@ -0,0 +1,5 @@
+# SigNoz Cloud Integrations
+
+Cloud integrations are unlike the rest of SigNoz integrations.
+They have a different UX and so require a different API.
+They will also be limited in number and are not expected to have community contributed implementations

pkg/query-service/app/cloudintegrations/accountsRepo.go

@@ -0,0 +1,220 @@
+package cloudintegrations
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/query-service/model"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/integrationtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type cloudProviderAccountsRepository interface {
+	listConnected(ctx context.Context, orgId string, provider string) ([]integrationtypes.CloudIntegration, *model.ApiError)
+
+	get(ctx context.Context, orgId string, provider string, id string) (*integrationtypes.CloudIntegration, *model.ApiError)
+
+	getConnectedCloudAccount(ctx context.Context, orgId string, provider string, accountID string) (*integrationtypes.CloudIntegration, *model.ApiError)
+
+	// Insert an account or update it by (cloudProvider, id)
+	// for specified non-empty fields
+	upsert(
+		ctx context.Context,
+		orgId string,
+		provider string,
+		id *string,
+		config *integrationtypes.AccountConfig,
+		accountId *string,
+		agentReport *integrationtypes.AgentReport,
+		removedAt *time.Time,
+	) (*integrationtypes.CloudIntegration, *model.ApiError)
+}
+
+func newCloudProviderAccountsRepository(store sqlstore.SQLStore) (
+	*cloudProviderAccountsSQLRepository, error,
+) {
+	return &cloudProviderAccountsSQLRepository{
+		store: store,
+	}, nil
+}
+
+type cloudProviderAccountsSQLRepository struct {
+	store sqlstore.SQLStore
+}
+
+func (r *cloudProviderAccountsSQLRepository) listConnected(
+	ctx context.Context, orgId string, cloudProvider string,
+) ([]integrationtypes.CloudIntegration, *model.ApiError) {
+	accounts := []integrationtypes.CloudIntegration{}
+
+	err := r.store.BunDB().NewSelect().
+		Model(&accounts).
+		Where("org_id = ?", orgId).
+		Where("provider = ?", cloudProvider).
+		Where("removed_at is NULL").
+		Where("account_id is not NULL").
+		Where("last_agent_report is not NULL").
+		Order("created_at").
+		Scan(ctx)
+
+	if err != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"could not query connected cloud accounts: %w", err,
+		))
+	}
+
+	return accounts, nil
+}
+
+func (r *cloudProviderAccountsSQLRepository) get(
+	ctx context.Context, orgId string, provider string, id string,
+) (*integrationtypes.CloudIntegration, *model.ApiError) {
+	var result integrationtypes.CloudIntegration
+
+	err := r.store.BunDB().NewSelect().
+		Model(&result).
+		Where("org_id = ?", orgId).
+		Where("provider = ?", provider).
+		Where("id = ?", id).
+		Scan(ctx)
+
+	if err == sql.ErrNoRows {
+		return nil, model.NotFoundError(fmt.Errorf(
+			"couldn't find account with Id %s", id,
+		))
+	} else if err != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"couldn't query cloud provider accounts: %w", err,
+		))
+	}
+
+	return &result, nil
+}
+
+func (r *cloudProviderAccountsSQLRepository) getConnectedCloudAccount(
+	ctx context.Context, orgId string, provider string, accountId string,
+) (*integrationtypes.CloudIntegration, *model.ApiError) {
+	var result integrationtypes.CloudIntegration
+
+	err := r.store.BunDB().NewSelect().
+		Model(&result).
+		Where("org_id = ?", orgId).
+		Where("provider = ?", provider).
+		Where("account_id = ?", accountId).
+		Where("last_agent_report is not NULL").
+		Where("removed_at is NULL").
+		Scan(ctx)
+
+	if err == sql.ErrNoRows {
+		return nil, model.NotFoundError(fmt.Errorf(
+			"couldn't find connected cloud account %s", accountId,
+		))
+	} else if err != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"couldn't query cloud provider accounts: %w", err,
+		))
+	}
+
+	return &result, nil
+}
+
+func (r *cloudProviderAccountsSQLRepository) upsert(
+	ctx context.Context,
+	orgId string,
+	provider string,
+	id *string,
+	config *integrationtypes.AccountConfig,
+	accountId *string,
+	agentReport *integrationtypes.AgentReport,
+	removedAt *time.Time,
+) (*integrationtypes.CloudIntegration, *model.ApiError) {
+	// Insert
+	if id == nil {
+		temp := valuer.GenerateUUID().StringValue()
+		id = &temp
+	}
+
+	// Prepare clause for setting values in `on conflict do update`
+	onConflictSetStmts := []string{}
+	setColStatement := func(col string) string {
+		return fmt.Sprintf("%s=excluded.%s", col, col)
+	}
+
+	if config != nil {
+		onConflictSetStmts = append(
+			onConflictSetStmts, setColStatement("config"),
+		)
+	}
+
+	if accountId != nil {
+		onConflictSetStmts = append(
+			onConflictSetStmts, setColStatement("account_id"),
+		)
+	}
+
+	if agentReport != nil {
+		onConflictSetStmts = append(
+			onConflictSetStmts, setColStatement("last_agent_report"),
+		)
+	}
+
+	if removedAt != nil {
+		onConflictSetStmts = append(
+			onConflictSetStmts, setColStatement("removed_at"),
+		)
+	}
+
+	// set updated_at to current timestamp if it's an upsert
+	onConflictSetStmts = append(
+		onConflictSetStmts, setColStatement("updated_at"),
+	)
+
+	onConflictClause := ""
+	if len(onConflictSetStmts) > 0 {
+		onConflictClause = fmt.Sprintf(
+			"conflict(id) do update SET\n%s",
+			strings.Join(onConflictSetStmts, ",\n"),
+		)
+	}
+
+	integration := integrationtypes.CloudIntegration{
+		OrgID:        orgId,
+		Provider:     provider,
+		Identifiable: types.Identifiable{ID: valuer.MustNewUUID(*id)},
+		TimeAuditable: types.TimeAuditable{
+			CreatedAt: time.Now(),
+			UpdatedAt: time.Now(),
+		},
+		Config:          config,
+		AccountID:       accountId,
+		LastAgentReport: agentReport,
+		RemovedAt:       removedAt,
+	}
+
+	_, dbErr := r.store.BunDB().NewInsert().
+		Model(&integration).
+		On(onConflictClause).
+		Exec(ctx)
+
+	if dbErr != nil {
+		// for now returning internal error even if there is a conflict,
+		// will be handled better in the future iteration
+		return nil, model.InternalError(fmt.Errorf(
+			"could not upsert cloud account record: %w", dbErr,
+		))
+	}
+
+	upsertedAccount, apiErr := r.get(ctx, orgId, provider, *id)
+	if apiErr != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"couldn't fetch upserted account by id: %w", apiErr.ToError(),
+		))
+	}
+
+	return upsertedAccount, nil
+}

pkg/query-service/app/cloudintegrations/constants.go

@@ -0,0 +1,43 @@
+package cloudintegrations
+
+import (
+	"github.com/SigNoz/signoz/pkg/errors"
+)
+
+var (
+	CodeInvalidCloudRegion    = errors.MustNewCode("invalid_cloud_region")
+	CodeMismatchCloudProvider = errors.MustNewCode("cloud_provider_mismatch")
+)
+
+// List of all valid cloud regions on Amazon Web Services
+var ValidAWSRegions = map[string]bool{
+	"af-south-1":     true, // Africa (Cape Town).
+	"ap-east-1":      true, // Asia Pacific (Hong Kong).
+	"ap-northeast-1": true, // Asia Pacific (Tokyo).
+	"ap-northeast-2": true, // Asia Pacific (Seoul).
+	"ap-northeast-3": true, // Asia Pacific (Osaka).
+	"ap-south-1":     true, // Asia Pacific (Mumbai).
+	"ap-south-2":     true, // Asia Pacific (Hyderabad).
+	"ap-southeast-1": true, // Asia Pacific (Singapore).
+	"ap-southeast-2": true, // Asia Pacific (Sydney).
+	"ap-southeast-3": true, // Asia Pacific (Jakarta).
+	"ap-southeast-4": true, // Asia Pacific (Melbourne).
+	"ca-central-1":   true, // Canada (Central).
+	"ca-west-1":      true, // Canada West (Calgary).
+	"eu-central-1":   true, // Europe (Frankfurt).
+	"eu-central-2":   true, // Europe (Zurich).
+	"eu-north-1":     true, // Europe (Stockholm).
+	"eu-south-1":     true, // Europe (Milan).
+	"eu-south-2":     true, // Europe (Spain).
+	"eu-west-1":      true, // Europe (Ireland).
+	"eu-west-2":      true, // Europe (London).
+	"eu-west-3":      true, // Europe (Paris).
+	"il-central-1":   true, // Israel (Tel Aviv).
+	"me-central-1":   true, // Middle East (UAE).
+	"me-south-1":     true, // Middle East (Bahrain).
+	"sa-east-1":      true, // South America (Sao Paulo).
+	"us-east-1":      true, // US East (N. Virginia).
+	"us-east-2":      true, // US East (Ohio).
+	"us-west-1":      true, // US West (N. California).
+	"us-west-2":      true, // US West (Oregon).
+}

pkg/query-service/app/cloudintegrations/controller.go

@@ -0,0 +1,625 @@
+package cloudintegrations
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/query-service/app/cloudintegrations/services"
+	"github.com/SigNoz/signoz/pkg/query-service/model"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
+	"github.com/SigNoz/signoz/pkg/types/integrationtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"golang.org/x/exp/maps"
+)
+
+var SupportedCloudProviders = []string{
+	"aws",
+}
+
+func validateCloudProviderName(name string) *model.ApiError {
+	if !slices.Contains(SupportedCloudProviders, name) {
+		return model.BadRequest(fmt.Errorf("invalid cloud provider: %s", name))
+	}
+	return nil
+}
+
+type Controller struct {
+	accountsRepo      cloudProviderAccountsRepository
+	serviceConfigRepo ServiceConfigDatabase
+}
+
+func NewController(sqlStore sqlstore.SQLStore) (*Controller, error) {
+	accountsRepo, err := newCloudProviderAccountsRepository(sqlStore)
+	if err != nil {
+		return nil, fmt.Errorf("couldn't create cloud provider accounts repo: %w", err)
+	}
+
+	serviceConfigRepo, err := newServiceConfigRepository(sqlStore)
+	if err != nil {
+		return nil, fmt.Errorf("couldn't create cloud provider service config repo: %w", err)
+	}
+
+	return &Controller{
+		accountsRepo:      accountsRepo,
+		serviceConfigRepo: serviceConfigRepo,
+	}, nil
+}
+
+type ConnectedAccountsListResponse struct {
+	Accounts []integrationtypes.Account `json:"accounts"`
+}
+
+func (c *Controller) ListConnectedAccounts(ctx context.Context, orgId string, cloudProvider string) (
+	*ConnectedAccountsListResponse, *model.ApiError,
+) {
+	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
+		return nil, apiErr
+	}
+
+	accountRecords, apiErr := c.accountsRepo.listConnected(ctx, orgId, cloudProvider)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't list cloud accounts")
+	}
+
+	connectedAccounts := []integrationtypes.Account{}
+	for _, a := range accountRecords {
+		connectedAccounts = append(connectedAccounts, a.Account())
+	}
+
+	return &ConnectedAccountsListResponse{
+		Accounts: connectedAccounts,
+	}, nil
+}
+
+type GenerateConnectionUrlRequest struct {
+	// Optional. To be specified for updates.
+	AccountId *string `json:"account_id,omitempty"`
+
+	AccountConfig integrationtypes.AccountConfig `json:"account_config"`
+
+	AgentConfig SigNozAgentConfig `json:"agent_config"`
+}
+
+type SigNozAgentConfig struct {
+	// The region in which SigNoz agent should be installed.
+	Region string `json:"region"`
+
+	IngestionUrl string `json:"ingestion_url"`
+	IngestionKey string `json:"ingestion_key"`
+	SigNozAPIUrl string `json:"signoz_api_url"`
+	SigNozAPIKey string `json:"signoz_api_key"`
+
+	Version string `json:"version,omitempty"`
+}
+
+type GenerateConnectionUrlResponse struct {
+	AccountId     string `json:"account_id"`
+	ConnectionUrl string `json:"connection_url"`
+}
+
+func (c *Controller) GenerateConnectionUrl(ctx context.Context, orgId string, cloudProvider string, req GenerateConnectionUrlRequest) (*GenerateConnectionUrlResponse, *model.ApiError) {
+	// Account connection with a simple connection URL may not be available for all providers.
+	if cloudProvider != "aws" {
+		return nil, model.BadRequest(fmt.Errorf("unsupported cloud provider: %s", cloudProvider))
+	}
+
+	account, apiErr := c.accountsRepo.upsert(
+		ctx, orgId, cloudProvider, req.AccountId, &req.AccountConfig, nil, nil, nil,
+	)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't upsert cloud account")
+	}
+
+	agentVersion := "v0.0.8"
+	if req.AgentConfig.Version != "" {
+		agentVersion = req.AgentConfig.Version
+	}
+
+	connectionUrl := fmt.Sprintf(
+		"https://%s.console.aws.amazon.com/cloudformation/home?region=%s#/stacks/quickcreate?",
+		req.AgentConfig.Region, req.AgentConfig.Region,
+	)
+
+	for qp, value := range map[string]string{
+		"param_SigNozIntegrationAgentVersion": agentVersion,
+		"param_SigNozApiUrl":                  req.AgentConfig.SigNozAPIUrl,
+		"param_SigNozApiKey":                  req.AgentConfig.SigNozAPIKey,
+		"param_SigNozAccountId":               account.ID.StringValue(),
+		"param_IngestionUrl":                  req.AgentConfig.IngestionUrl,
+		"param_IngestionKey":                  req.AgentConfig.IngestionKey,
+		"stackName":                           "signoz-integration",
+		"templateURL": fmt.Sprintf(
+			"https://signoz-integrations.s3.us-east-1.amazonaws.com/aws-quickcreate-template-%s.json",
+			agentVersion,
+		),
+	} {
+		connectionUrl += fmt.Sprintf("&%s=%s", qp, url.QueryEscape(value))
+	}
+
+	return &GenerateConnectionUrlResponse{
+		AccountId:     account.ID.StringValue(),
+		ConnectionUrl: connectionUrl,
+	}, nil
+}
+
+type AccountStatusResponse struct {
+	Id             string                         `json:"id"`
+	CloudAccountId *string                        `json:"cloud_account_id,omitempty"`
+	Status         integrationtypes.AccountStatus `json:"status"`
+}
+
+func (c *Controller) GetAccountStatus(ctx context.Context, orgId string, cloudProvider string, accountId string) (
+	*AccountStatusResponse, *model.ApiError,
+) {
+	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
+		return nil, apiErr
+	}
+
+	account, apiErr := c.accountsRepo.get(ctx, orgId, cloudProvider, accountId)
+	if apiErr != nil {
+		return nil, apiErr
+	}
+
+	resp := AccountStatusResponse{
+		Id:             account.ID.StringValue(),
+		CloudAccountId: account.AccountID,
+		Status:         account.Status(),
+	}
+
+	return &resp, nil
+}
+
+type AgentCheckInRequest struct {
+	ID        string `json:"account_id"`
+	AccountID string `json:"cloud_account_id"`
+	// Arbitrary cloud specific Agent data
+	Data map[string]any `json:"data,omitempty"`
+}
+
+type AgentCheckInResponse struct {
+	AccountId      string     `json:"account_id"`
+	CloudAccountId string     `json:"cloud_account_id"`
+	RemovedAt      *time.Time `json:"removed_at"`
+
+	IntegrationConfig IntegrationConfigForAgent `json:"integration_config"`
+}
+
+type IntegrationConfigForAgent struct {
+	EnabledRegions []string `json:"enabled_regions"`
+
+	TelemetryCollectionStrategy *CompiledCollectionStrategy `json:"telemetry,omitempty"`
+}
+
+func (c *Controller) CheckInAsAgent(ctx context.Context, orgId string, cloudProvider string, req AgentCheckInRequest) (*AgentCheckInResponse, error) {
+	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
+		return nil, apiErr
+	}
+
+	existingAccount, apiErr := c.accountsRepo.get(ctx, orgId, cloudProvider, req.ID)
+	if existingAccount != nil && existingAccount.AccountID != nil && *existingAccount.AccountID != req.AccountID {
+		return nil, model.BadRequest(fmt.Errorf(
+			"can't check in with new %s account id %s for account %s with existing %s id %s",
+			cloudProvider, req.AccountID, existingAccount.ID.StringValue(), cloudProvider, *existingAccount.AccountID,
+		))
+	}
+
+	existingAccount, apiErr = c.accountsRepo.getConnectedCloudAccount(ctx, orgId, cloudProvider, req.AccountID)
+	if existingAccount != nil && existingAccount.ID.StringValue() != req.ID {
+		return nil, model.BadRequest(fmt.Errorf(
+			"can't check in to %s account %s with id %s. already connected with id %s",
+			cloudProvider, req.AccountID, req.ID, existingAccount.ID.StringValue(),
+		))
+	}
+
+	agentReport := integrationtypes.AgentReport{
+		TimestampMillis: time.Now().UnixMilli(),
+		Data:            req.Data,
+	}
+
+	account, apiErr := c.accountsRepo.upsert(
+		ctx, orgId, cloudProvider, &req.ID, nil, &req.AccountID, &agentReport, nil,
+	)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't upsert cloud account")
+	}
+
+	// prepare and return integration config to be consumed by agent
+	compiledStrategy, err := NewCompiledCollectionStrategy(cloudProvider)
+	if err != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"couldn't init telemetry collection strategy: %w", err,
+		))
+	}
+
+	agentConfig := IntegrationConfigForAgent{
+		EnabledRegions:              []string{},
+		TelemetryCollectionStrategy: compiledStrategy,
+	}
+
+	if account.Config != nil && account.Config.EnabledRegions != nil {
+		agentConfig.EnabledRegions = account.Config.EnabledRegions
+	}
+
+	services, err := services.Map(cloudProvider)
+	if err != nil {
+		return nil, err
+	}
+
+	svcConfigs, apiErr := c.serviceConfigRepo.getAllForAccount(
+		ctx, orgId, account.ID.StringValue(),
+	)
+	if apiErr != nil {
+		return nil, model.WrapApiError(
+			apiErr, "couldn't get service configs for cloud account",
+		)
+	}
+
+	// accumulate config in a fixed order to ensure same config generated across runs
+	configuredServices := maps.Keys(svcConfigs)
+	slices.Sort(configuredServices)
+
+	for _, svcType := range configuredServices {
+		definition, ok := services[svcType]
+		if !ok {
+			continue
+		}
+		config := svcConfigs[svcType]
+
+		err := AddServiceStrategy(svcType, compiledStrategy, definition.Strategy, config)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return &AgentCheckInResponse{
+		AccountId:         account.ID.StringValue(),
+		CloudAccountId:    *account.AccountID,
+		RemovedAt:         account.RemovedAt,
+		IntegrationConfig: agentConfig,
+	}, nil
+}
+
+type UpdateAccountConfigRequest struct {
+	Config integrationtypes.AccountConfig `json:"config"`
+}
+
+func (c *Controller) UpdateAccountConfig(ctx context.Context, orgId string, cloudProvider string, accountId string, req UpdateAccountConfigRequest) (*integrationtypes.Account, *model.ApiError) {
+	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
+		return nil, apiErr
+	}
+
+	accountRecord, apiErr := c.accountsRepo.upsert(
+		ctx, orgId, cloudProvider, &accountId, &req.Config, nil, nil, nil,
+	)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't upsert cloud account")
+	}
+
+	account := accountRecord.Account()
+
+	return &account, nil
+}
+
+func (c *Controller) DisconnectAccount(ctx context.Context, orgId string, cloudProvider string, accountId string) (*integrationtypes.CloudIntegration, *model.ApiError) {
+	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
+		return nil, apiErr
+	}
+
+	account, apiErr := c.accountsRepo.get(ctx, orgId, cloudProvider, accountId)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't disconnect account")
+	}
+
+	tsNow := time.Now()
+	account, apiErr = c.accountsRepo.upsert(
+		ctx, orgId, cloudProvider, &accountId, nil, nil, nil, &tsNow,
+	)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't disconnect account")
+	}
+
+	return account, nil
+}
+
+type ListServicesResponse struct {
+	Services []ServiceSummary `json:"services"`
+}
+
+func (c *Controller) ListServices(
+	ctx context.Context,
+	orgID string,
+	cloudProvider string,
+	cloudAccountId *string,
+) (*ListServicesResponse, *model.ApiError) {
+	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
+		return nil, apiErr
+	}
+
+	definitions, apiErr := services.List(cloudProvider)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't list cloud services")
+	}
+
+	svcConfigs := map[string]*integrationtypes.CloudServiceConfig{}
+	if cloudAccountId != nil {
+		activeAccount, apiErr := c.accountsRepo.getConnectedCloudAccount(
+			ctx, orgID, cloudProvider, *cloudAccountId,
+		)
+		if apiErr != nil {
+			return nil, model.WrapApiError(apiErr, "couldn't get active account")
+		}
+		svcConfigs, apiErr = c.serviceConfigRepo.getAllForAccount(
+			ctx, orgID, activeAccount.ID.StringValue(),
+		)
+		if apiErr != nil {
+			return nil, model.WrapApiError(
+				apiErr, "couldn't get service configs for cloud account",
+			)
+		}
+	}
+
+	summaries := []ServiceSummary{}
+	for _, def := range definitions {
+		summary := ServiceSummary{
+			Metadata: def.Metadata,
+		}
+		summary.Config = svcConfigs[summary.Id]
+
+		summaries = append(summaries, summary)
+	}
+
+	return &ListServicesResponse{
+		Services: summaries,
+	}, nil
+}
+
+func (c *Controller) GetServiceDetails(
+	ctx context.Context,
+	orgID string,
+	cloudProvider string,
+	serviceId string,
+	cloudAccountId *string,
+) (*ServiceDetails, error) {
+	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
+		return nil, apiErr
+	}
+
+	definition, err := services.GetServiceDefinition(cloudProvider, serviceId)
+	if err != nil {
+		return nil, err
+	}
+
+	details := ServiceDetails{
+		Definition: *definition,
+	}
+
+	if cloudAccountId != nil {
+
+		activeAccount, apiErr := c.accountsRepo.getConnectedCloudAccount(
+			ctx, orgID, cloudProvider, *cloudAccountId,
+		)
+		if apiErr != nil {
+			return nil, model.WrapApiError(apiErr, "couldn't get active account")
+		}
+
+		config, apiErr := c.serviceConfigRepo.get(
+			ctx, orgID, activeAccount.ID.StringValue(), serviceId,
+		)
+		if apiErr != nil && apiErr.Type() != model.ErrorNotFound {
+			return nil, model.WrapApiError(apiErr, "couldn't fetch service config")
+		}
+
+		if config != nil {
+			details.Config = config
+
+			enabled := false
+			if config.Metrics != nil && config.Metrics.Enabled {
+				enabled = true
+			}
+
+			// add links to service dashboards, making them clickable.
+			for i, d := range definition.Assets.Dashboards {
+				dashboardUuid := c.dashboardUuid(
+					cloudProvider, serviceId, d.Id,
+				)
+				if enabled {
+					definition.Assets.Dashboards[i].Url = fmt.Sprintf("/dashboard/%s", dashboardUuid)
+				} else {
+					definition.Assets.Dashboards[i].Url = "" // to unset the in-memory URL if enabled once and disabled afterwards
+				}
+			}
+		}
+	}
+
+	return &details, nil
+}
+
+type UpdateServiceConfigRequest struct {
+	CloudAccountId string                              `json:"cloud_account_id"`
+	Config         integrationtypes.CloudServiceConfig `json:"config"`
+}
+
+func (u *UpdateServiceConfigRequest) Validate(def *services.Definition) error {
+	if def.Id != services.S3Sync && u.Config.Logs != nil && u.Config.Logs.S3Buckets != nil {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "s3 buckets can only be added to service-type[%s]", services.S3Sync)
+	} else if def.Id == services.S3Sync && u.Config.Logs != nil && u.Config.Logs.S3Buckets != nil {
+		for region := range u.Config.Logs.S3Buckets {
+			if _, found := ValidAWSRegions[region]; !found {
+				return errors.NewInvalidInputf(CodeInvalidCloudRegion, "invalid cloud region: %s", region)
+			}
+		}
+	}
+
+	return nil
+}
+
+type UpdateServiceConfigResponse struct {
+	Id     string                              `json:"id"`
+	Config integrationtypes.CloudServiceConfig `json:"config"`
+}
+
+func (c *Controller) UpdateServiceConfig(
+	ctx context.Context,
+	orgID string,
+	cloudProvider string,
+	serviceType string,
+	req *UpdateServiceConfigRequest,
+) (*UpdateServiceConfigResponse, error) {
+	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
+		return nil, apiErr
+	}
+
+	// can only update config for a valid service.
+	definition, err := services.GetServiceDefinition(cloudProvider, serviceType)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := req.Validate(definition); err != nil {
+		return nil, err
+	}
+
+	// can only update config for a connected cloud account id
+	_, apiErr := c.accountsRepo.getConnectedCloudAccount(
+		ctx, orgID, cloudProvider, req.CloudAccountId,
+	)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't find connected cloud account")
+	}
+
+	updatedConfig, apiErr := c.serviceConfigRepo.upsert(
+		ctx, orgID, cloudProvider, req.CloudAccountId, serviceType, req.Config,
+	)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't update service config")
+	}
+
+	return &UpdateServiceConfigResponse{
+		Id:     serviceType,
+		Config: *updatedConfig,
+	}, nil
+}
+
+// All dashboards that are available based on cloud integrations configuration
+// across all cloud providers
+func (c *Controller) AvailableDashboards(ctx context.Context, orgId valuer.UUID) ([]*dashboardtypes.Dashboard, *model.ApiError) {
+	allDashboards := []*dashboardtypes.Dashboard{}
+
+	for _, provider := range []string{"aws"} {
+		providerDashboards, apiErr := c.AvailableDashboardsForCloudProvider(ctx, orgId, provider)
+		if apiErr != nil {
+			return nil, model.WrapApiError(
+				apiErr, fmt.Sprintf("couldn't get available dashboards for %s", provider),
+			)
+		}
+
+		allDashboards = append(allDashboards, providerDashboards...)
+	}
+
+	return allDashboards, nil
+}
+
+func (c *Controller) AvailableDashboardsForCloudProvider(ctx context.Context, orgID valuer.UUID, cloudProvider string) ([]*dashboardtypes.Dashboard, *model.ApiError) {
+	accountRecords, apiErr := c.accountsRepo.listConnected(ctx, orgID.StringValue(), cloudProvider)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't list connected cloud accounts")
+	}
+
+	// for v0, service dashboards are only available when metrics are enabled.
+	servicesWithAvailableMetrics := map[string]*time.Time{}
+
+	for _, ar := range accountRecords {
+		if ar.AccountID != nil {
+			configsBySvcId, apiErr := c.serviceConfigRepo.getAllForAccount(
+				ctx, orgID.StringValue(), ar.ID.StringValue(),
+			)
+			if apiErr != nil {
+				return nil, apiErr
+			}
+
+			for svcId, config := range configsBySvcId {
+				if config.Metrics != nil && config.Metrics.Enabled {
+					servicesWithAvailableMetrics[svcId] = &ar.CreatedAt
+				}
+			}
+		}
+	}
+
+	allServices, apiErr := services.List(cloudProvider)
+	if apiErr != nil {
+		return nil, apiErr
+	}
+
+	svcDashboards := []*dashboardtypes.Dashboard{}
+	for _, svc := range allServices {
+		serviceDashboardsCreatedAt := servicesWithAvailableMetrics[svc.Id]
+		if serviceDashboardsCreatedAt != nil {
+			for _, d := range svc.Assets.Dashboards {
+				author := fmt.Sprintf("%s-integration", cloudProvider)
+				svcDashboards = append(svcDashboards, &dashboardtypes.Dashboard{
+					ID:     c.dashboardUuid(cloudProvider, svc.Id, d.Id),
+					Locked: true,
+					Data:   *d.Definition,
+					TimeAuditable: types.TimeAuditable{
+						CreatedAt: *serviceDashboardsCreatedAt,
+						UpdatedAt: *serviceDashboardsCreatedAt,
+					},
+					UserAuditable: types.UserAuditable{
+						CreatedBy: author,
+						UpdatedBy: author,
+					},
+					OrgID: orgID,
+				})
+			}
+			servicesWithAvailableMetrics[svc.Id] = nil
+		}
+	}
+
+	return svcDashboards, nil
+}
+func (c *Controller) GetDashboardById(ctx context.Context, orgId valuer.UUID, dashboardUuid string) (*dashboardtypes.Dashboard, *model.ApiError) {
+	cloudProvider, _, _, apiErr := c.parseDashboardUuid(dashboardUuid)
+	if apiErr != nil {
+		return nil, apiErr
+	}
+
+	allDashboards, apiErr := c.AvailableDashboardsForCloudProvider(ctx, orgId, cloudProvider)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't list available dashboards")
+	}
+
+	for _, d := range allDashboards {
+		if d.ID == dashboardUuid {
+			return d, nil
+		}
+	}
+
+	return nil, model.NotFoundError(fmt.Errorf("couldn't find dashboard with uuid: %s", dashboardUuid))
+}
+
+func (c *Controller) dashboardUuid(
+	cloudProvider string, svcId string, dashboardId string,
+) string {
+	return fmt.Sprintf("cloud-integration--%s--%s--%s", cloudProvider, svcId, dashboardId)
+}
+
+func (c *Controller) parseDashboardUuid(dashboardUuid string) (cloudProvider string, svcId string, dashboardId string, apiErr *model.ApiError) {
+	parts := strings.SplitN(dashboardUuid, "--", 4)
+	if len(parts) != 4 || parts[0] != "cloud-integration" {
+		return "", "", "", model.BadRequest(fmt.Errorf("invalid cloud integration dashboard id"))
+	}
+
+	return parts[1], parts[2], parts[3], nil
+}
+
+func (c *Controller) IsCloudIntegrationDashboardUuid(dashboardUuid string) bool {
+	_, _, _, apiErr := c.parseDashboardUuid(dashboardUuid)
+	return apiErr == nil
+}

pkg/query-service/app/cloudintegrations/models.go

@@ -0,0 +1,94 @@
+package cloudintegrations
+
+import (
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/query-service/app/cloudintegrations/services"
+	"github.com/SigNoz/signoz/pkg/types/integrationtypes"
+)
+
+type ServiceSummary struct {
+	services.Metadata
+
+	Config *integrationtypes.CloudServiceConfig `json:"config"`
+}
+
+type ServiceDetails struct {
+	services.Definition
+
+	Config           *integrationtypes.CloudServiceConfig `json:"config"`
+	ConnectionStatus *ServiceConnectionStatus             `json:"status,omitempty"`
+}
+
+type AccountStatus struct {
+	Integration AccountIntegrationStatus `json:"integration"`
+}
+
+type AccountIntegrationStatus struct {
+	LastHeartbeatTsMillis *int64 `json:"last_heartbeat_ts_ms"`
+}
+
+type LogsConfig struct {
+	Enabled   bool                `json:"enabled"`
+	S3Buckets map[string][]string `json:"s3_buckets,omitempty"`
+}
+
+type MetricsConfig struct {
+	Enabled bool `json:"enabled"`
+}
+
+type ServiceConnectionStatus struct {
+	Logs    *SignalConnectionStatus `json:"logs"`
+	Metrics *SignalConnectionStatus `json:"metrics"`
+}
+
+type SignalConnectionStatus struct {
+	LastReceivedTsMillis int64  `json:"last_received_ts_ms"` // epoch milliseconds
+	LastReceivedFrom     string `json:"last_received_from"`  // resource identifier
+}
+
+type CompiledCollectionStrategy = services.CollectionStrategy
+
+func NewCompiledCollectionStrategy(provider string) (*CompiledCollectionStrategy, error) {
+	if provider == "aws" {
+		return &CompiledCollectionStrategy{
+			Provider:   "aws",
+			AWSMetrics: &services.AWSMetricsStrategy{},
+			AWSLogs:    &services.AWSLogsStrategy{},
+		}, nil
+	}
+	return nil, errors.NewNotFoundf(services.CodeUnsupportedCloudProvider, "unsupported cloud provider: %s", provider)
+}
+
+// Helper for accumulating strategies for enabled services.
+func AddServiceStrategy(serviceType string, cs *CompiledCollectionStrategy,
+	definitionStrat *services.CollectionStrategy, config *integrationtypes.CloudServiceConfig) error {
+	if definitionStrat.Provider != cs.Provider {
+		return errors.NewInternalf(CodeMismatchCloudProvider, "can't add %s service strategy to compiled strategy for %s",
+			definitionStrat.Provider, cs.Provider)
+	}
+
+	if cs.Provider == "aws" {
+		if config.Logs != nil && config.Logs.Enabled {
+			if serviceType == services.S3Sync {
+				// S3 bucket sync; No cloudwatch logs are appended for this service type;
+				// Though definition is populated with a custom cloudwatch group that helps in calculating logs connection status
+				cs.S3Buckets = config.Logs.S3Buckets
+			} else if definitionStrat.AWSLogs != nil { // services that includes a logs subscription
+				cs.AWSLogs.Subscriptions = append(
+					cs.AWSLogs.Subscriptions,
+					definitionStrat.AWSLogs.Subscriptions...,
+				)
+			}
+		}
+		if config.Metrics != nil && config.Metrics.Enabled && definitionStrat.AWSMetrics != nil {
+			cs.AWSMetrics.StreamFilters = append(
+				cs.AWSMetrics.StreamFilters,
+				definitionStrat.AWSMetrics.StreamFilters...,
+			)
+		}
+
+		return nil
+	}
+
+	return errors.NewNotFoundf(services.CodeUnsupportedCloudProvider, "unsupported cloud provider: %s", cs.Provider)
+}

pkg/query-service/app/cloudintegrations/serviceconfig_db.go

@@ -0,0 +1,165 @@
+package cloudintegrations
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/query-service/model"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/integrationtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type ServiceConfigDatabase interface {
+	get(
+		ctx context.Context,
+		orgID string,
+		cloudAccountId string,
+		serviceType string,
+	) (*integrationtypes.CloudServiceConfig, *model.ApiError)
+
+	upsert(
+		ctx context.Context,
+		orgID string,
+		cloudProvider string,
+		cloudAccountId string,
+		serviceId string,
+		config integrationtypes.CloudServiceConfig,
+	) (*integrationtypes.CloudServiceConfig, *model.ApiError)
+
+	getAllForAccount(
+		ctx context.Context,
+		orgID string,
+		cloudAccountId string,
+	) (
+		configsBySvcId map[string]*integrationtypes.CloudServiceConfig,
+		apiErr *model.ApiError,
+	)
+}
+
+func newServiceConfigRepository(store sqlstore.SQLStore) (
+	*serviceConfigSQLRepository, error,
+) {
+	return &serviceConfigSQLRepository{
+		store: store,
+	}, nil
+}
+
+type serviceConfigSQLRepository struct {
+	store sqlstore.SQLStore
+}
+
+func (r *serviceConfigSQLRepository) get(
+	ctx context.Context,
+	orgID string,
+	cloudAccountId string,
+	serviceType string,
+) (*integrationtypes.CloudServiceConfig, *model.ApiError) {
+
+	var result integrationtypes.CloudIntegrationService
+
+	err := r.store.BunDB().NewSelect().
+		Model(&result).
+		Join("JOIN cloud_integration ci ON ci.id = cis.cloud_integration_id").
+		Where("ci.org_id = ?", orgID).
+		Where("ci.id = ?", cloudAccountId).
+		Where("cis.type = ?", serviceType).
+		Scan(ctx)
+
+	if err == sql.ErrNoRows {
+		return nil, model.NotFoundError(fmt.Errorf(
+			"couldn't find config for cloud account %s",
+			cloudAccountId,
+		))
+	} else if err != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"couldn't query cloud service config: %w", err,
+		))
+	}
+
+	return &result.Config, nil
+
+}
+
+func (r *serviceConfigSQLRepository) upsert(
+	ctx context.Context,
+	orgID string,
+	cloudProvider string,
+	cloudAccountId string,
+	serviceId string,
+	config integrationtypes.CloudServiceConfig,
+) (*integrationtypes.CloudServiceConfig, *model.ApiError) {
+
+	// get cloud integration id from account id
+	// if the account is not connected, we don't need to upsert the config
+	var cloudIntegrationId string
+	err := r.store.BunDB().NewSelect().
+		Model((*integrationtypes.CloudIntegration)(nil)).
+		Column("id").
+		Where("provider = ?", cloudProvider).
+		Where("account_id = ?", cloudAccountId).
+		Where("org_id = ?", orgID).
+		Where("removed_at is NULL").
+		Where("last_agent_report is not NULL").
+		Scan(ctx, &cloudIntegrationId)
+
+	if err != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"couldn't query cloud integration id: %w", err,
+		))
+	}
+
+	serviceConfig := integrationtypes.CloudIntegrationService{
+		Identifiable: types.Identifiable{ID: valuer.GenerateUUID()},
+		TimeAuditable: types.TimeAuditable{
+			CreatedAt: time.Now(),
+			UpdatedAt: time.Now(),
+		},
+		Config:             config,
+		Type:               serviceId,
+		CloudIntegrationID: cloudIntegrationId,
+	}
+	_, err = r.store.BunDB().NewInsert().
+		Model(&serviceConfig).
+		On("conflict(cloud_integration_id, type) do update set config=excluded.config, updated_at=excluded.updated_at").
+		Exec(ctx)
+	if err != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"could not upsert cloud service config: %w", err,
+		))
+	}
+
+	return &serviceConfig.Config, nil
+
+}
+
+func (r *serviceConfigSQLRepository) getAllForAccount(
+	ctx context.Context,
+	orgID string,
+	cloudAccountId string,
+) (map[string]*integrationtypes.CloudServiceConfig, *model.ApiError) {
+	serviceConfigs := []integrationtypes.CloudIntegrationService{}
+
+	err := r.store.BunDB().NewSelect().
+		Model(&serviceConfigs).
+		Join("JOIN cloud_integration ci ON ci.id = cis.cloud_integration_id").
+		Where("ci.id = ?", cloudAccountId).
+		Where("ci.org_id = ?", orgID).
+		Scan(ctx)
+	if err != nil {
+		return nil, model.InternalError(fmt.Errorf(
+			"could not query service configs from db: %w", err,
+		))
+	}
+
+	result := map[string]*integrationtypes.CloudServiceConfig{}
+
+	for _, r := range serviceConfigs {
+		result[r.Type] = &r.Config
+	}
+
+	return result, nil
+}

pkg/query-service/app/cloudintegrations/services/definitions/aws/alb/icon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 85 85" fill="#fff" fill-rule="evenodd" stroke="#000" stroke-linecap="round" stroke-linejoin="round"><use xlink:href="#A" x="2.5" y="2.5"/><symbol id="A" overflow="visible"><g stroke="none"><path d="M0 41.579C0 20.293 17.84 3.157 40 3.157s40 17.136 40 38.422S62.16 80 40 80 0 62.864 0 41.579z" fill="#9d5025"/><path d="M0 38.422C0 17.136 17.84 0 40 0s40 17.136 40 38.422-17.84 38.422-40 38.422S0 59.707 0 38.422z" fill="#f58536"/><path d="M51.672 7.387v13.952H28.327V7.387zm18.061 40.378v11.364h-11.83V47.765zm-14.958 0v11.364h-11.83V47.765zm-18.206 0v11.364h-11.83V47.765zm-14.959 0v11.364H9.78V47.765z"/><path d="M14.63 37.929h2.13v11.149h-2.13z"/><path d="M14.63 37.929h17.088v2.045H14.63z"/><path d="M29.589 37.929h2.13v11.149H29.59zm18.206 0h2.13v11.149h-2.13z"/><path d="M47.795 37.929h17.088v2.045H47.795z"/><path d="M62.754 37.929h2.13v11.149h-2.129zm-40.631-7.954h2.13v8.977h-2.13zM38.935 19.28h2.13v10.859h-2.129z"/><path d="M22.123 29.116h35.32v2.045h-35.32z"/><path d="M55.314 29.975h2.13v8.977h-2.129z"/></g></symbol></svg>

pkg/query-service/app/cloudintegrations/services/definitions/aws/alb/integration.json

@@ -0,0 +1,467 @@
+{
+  "id": "alb",
+  "title": "ALB",
+  "icon": "file://icon.svg",
+  "overview": "file://overview.md",
+  "supported_signals": {
+    "metrics": true,
+    "logs": false
+  },
+  "data_collected": {
+    "metrics": [
+      {
+        "name": "aws_ApplicationELB_ActiveConnectionCount_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ActiveConnectionCount_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ActiveConnectionCount_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ActiveConnectionCount_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_AnomalousHostCount_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_AnomalousHostCount_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_AnomalousHostCount_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_AnomalousHostCount_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ConsumedLCUs_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ConsumedLCUs_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ConsumedLCUs_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ConsumedLCUs_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HTTPCode_Target_2XX_Count_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HTTPCode_Target_2XX_Count_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HTTPCode_Target_2XX_Count_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HTTPCode_Target_2XX_Count_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HTTPCode_Target_4XX_Count_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HTTPCode_Target_4XX_Count_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HTTPCode_Target_4XX_Count_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HTTPCode_Target_4XX_Count_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyHostCount_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyHostCount_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyHostCount_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyHostCount_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyStateDNS_count",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyStateDNS_max",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyStateDNS_min",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyStateDNS_sum",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyStateRouting_count",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyStateRouting_max",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyStateRouting_min",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_HealthyStateRouting_sum",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_MitigatedHostCount_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_MitigatedHostCount_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_MitigatedHostCount_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_MitigatedHostCount_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_NewConnectionCount_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_NewConnectionCount_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_NewConnectionCount_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_NewConnectionCount_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_PeakLCUs_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_PeakLCUs_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_PeakLCUs_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_PeakLCUs_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ProcessedBytes_count",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ProcessedBytes_max",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ProcessedBytes_min",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_ProcessedBytes_sum",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_RequestCountPerTarget_count",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_RequestCountPerTarget_max",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_RequestCountPerTarget_min",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_RequestCountPerTarget_sum",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_RequestCount_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_RequestCount_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_RequestCount_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_RequestCount_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_TargetResponseTime_count",
+        "unit": "Seconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_TargetResponseTime_max",
+        "unit": "Seconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_TargetResponseTime_min",
+        "unit": "Seconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_TargetResponseTime_sum",
+        "unit": "Seconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnHealthyHostCount_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnHealthyHostCount_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnHealthyHostCount_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnHealthyHostCount_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnhealthyStateDNS_count",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnhealthyStateDNS_max",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnhealthyStateDNS_min",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnhealthyStateDNS_sum",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnhealthyStateRouting_count",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnhealthyStateRouting_max",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnhealthyStateRouting_min",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_ApplicationELB_UnhealthyStateRouting_sum",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      }
+    ],
+    "logs": []
+  },
+  "telemetry_collection_strategy": {
+    "aws_metrics": {
+      "cloudwatch_metric_stream_filters": [
+        {
+          "Namespace": "AWS/ApplicationELB"
+        }
+      ]
+    }
+  },
+  "assets": {
+    "dashboards": [
+      {
+        "id": "overview",
+        "title": "ALB Overview",
+        "description": "Overview of Application Load Balancer",
+        "image": "file://assets/dashboards/overview.png",
+        "definition": "file://assets/dashboards/overview.json"
+      }
+    ]
+  }
+}

pkg/query-service/app/cloudintegrations/services/definitions/aws/alb/overview.md

@@ -0,0 +1,3 @@
+### Monitor Application Load Balancers with SigNoz
+
+Collect key ALB metrics and view them with an out of the box dashboard.

pkg/query-service/app/cloudintegrations/services/definitions/aws/api-gateway/icon.svg

@@ -0,0 +1,14 @@
+<svg width="24px" height="24px" viewBox="0 0 24 24" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <defs>
+        <linearGradient x1="0%" y1="100%" x2="100%" y2="0%" id="linearGradient-1">
+            <stop stop-color="#4D27A8" offset="0%"></stop>
+            <stop stop-color="#A166FF" offset="100%"></stop>
+        </linearGradient>
+    </defs>
+    <g stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g fill="url(#linearGradient-1)">
+            <rect id="Rectangle" x="0" y="0" width="24" height="24"></rect>
+        </g>
+        <path d="M6,6.76751613 L8,5.43446738 L8,18.5659476 L6,17.2328988 L6,6.76751613 Z M5,6.49950633 L5,17.4999086 C5,17.6669147 5.084,17.8239204 5.223,17.9159238 L8.223,19.9159969 C8.307,19.971999 8.403,20 8.5,20 C8.581,20 8.662,19.9809993 8.736,19.9409978 C8.898,19.8539947 9,19.6849885 9,19.4999817 L9,16.9998903 L10,16.9998903 L10,15.9998537 L9,15.9998537 L9,7.99956118 L10,7.99956118 L10,6.99952461 L9,6.99952461 L9,4.49943319 C9,4.31542646 8.898,4.14542025 8.736,4.0594171 C8.574,3.97241392 8.377,3.98141425 8.223,4.08341798 L5.223,6.08349112 C5.084,6.17649452 5,6.33250022 5,6.49950633 L5,6.49950633 Z M19,17.2328988 L17,18.5659476 L17,5.43446738 L19,6.76751613 L19,17.2328988 Z M19.777,6.08349112 L16.777,4.08341798 C16.623,3.98141425 16.426,3.97241392 16.264,4.0594171 C16.102,4.14542025 16,4.31542646 16,4.49943319 L16,6.99952461 L15,6.99952461 L15,7.99956118 L16,7.99956118 L16,15.9998537 L15,15.9998537 L15,16.9998903 L16,16.9998903 L16,19.4999817 C16,19.6849885 16.102,19.8539947 16.264,19.9409978 C16.338,19.9809993 16.419,20 16.5,20 C16.597,20 16.693,19.971999 16.777,19.9159969 L19.777,17.9159238 C19.916,17.8239204 20,17.6669147 20,17.4999086 L20,6.49950633 C20,6.33250022 19.916,6.17649452 19.777,6.08349112 L19.777,6.08349112 Z M13,7.99956118 L14,7.99956118 L14,6.99952461 L13,6.99952461 L13,7.99956118 Z M11,7.99956118 L12,7.99956118 L12,6.99952461 L11,6.99952461 L11,7.99956118 Z M13,16.9998903 L14,16.9998903 L14,15.9998537 L13,15.9998537 L13,16.9998903 Z M11,16.9998903 L12,16.9998903 L12,15.9998537 L11,15.9998537 L11,16.9998903 Z M13.18,14.884813 L10.18,12.3847215 C10.065,12.288718 10,12.1487129 10,11.9997075 C10,11.851702 10.065,11.7106969 10.18,11.6156934 L13.18,9.11560199 L13.82,9.88463011 L11.281,11.9997075 L13.82,14.1157848 L13.18,14.884813 Z" id="Amazon-API-Gateway_Icon_16_Squid" fill="#FFFFFF"></path>
+    </g>
+</svg>

pkg/query-service/app/cloudintegrations/services/definitions/aws/api-gateway/integration.json

@@ -0,0 +1,199 @@
+{
+  "id": "api-gateway",
+  "title": "API Gateway",
+  "icon": "file://icon.svg",
+  "overview": "file://overview.md",
+  "supported_signals": {
+    "metrics": true,
+    "logs": true
+  },
+  "data_collected": {
+    "metrics": [
+      {
+        "name": "aws_ApiGateway_4XXError_count",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_4XXError_max",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_4XXError_min",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_4XXError_sum",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_5XXError_count",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_5XXError_max",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_5XXError_min",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_5XXError_sum",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_CacheHitCount_count",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_CacheHitCount_max",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_CacheHitCount_min",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_CacheHitCount_sum",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_CacheMissCount_count",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_CacheMissCount_max",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_CacheMissCount_min",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_CacheMissCount_sum",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_Count_count",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_Count_max",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_Count_min",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_Count_sum",
+        "unit": "Count",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_IntegrationLatency_count",
+        "unit": "Milliseconds",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_IntegrationLatency_max",
+        "unit": "Milliseconds",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_IntegrationLatency_min",
+        "unit": "Milliseconds",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_IntegrationLatency_sum",
+        "unit": "Milliseconds",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_Latency_count",
+        "unit": "Milliseconds",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_Latency_max",
+        "unit": "Milliseconds",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_Latency_min",
+        "unit": "Milliseconds",
+        "type": "Gauge"
+      },
+      {
+        "name": "aws_ApiGateway_Latency_sum",
+        "unit": "Milliseconds",
+        "type": "Gauge"
+      }
+    ],
+    "logs": [
+      {
+        "name": "Account Id",
+        "path": "resources.cloud.account.id",
+        "type": "string"
+      },
+      {
+        "name": "Log Group Name",
+        "path": "resources.aws.cloudwatch.log_group_name",
+        "type": "string"
+      },
+      {
+        "name": "Log Stream Name",
+        "path": "resources.aws.cloudwatch.log_stream_name",
+        "type": "string"
+      }
+    ]
+  },
+  "telemetry_collection_strategy": {
+    "aws_metrics": {
+      "cloudwatch_metric_stream_filters": [
+        {
+          "Namespace": "AWS/ApiGateway"
+        }
+      ]
+    },
+    "aws_logs": {
+      "cloudwatch_logs_subscriptions": [
+        {
+          "log_group_name_prefix": "API-Gateway",
+          "filter_pattern": ""
+        }
+      ]
+    }
+  },
+  "assets": {
+    "dashboards": [
+      {
+        "id": "overview",
+        "title": "API Gateway Overview",
+        "description": "Overview of API Gateway",
+        "image": "file://assets/dashboards/overview.png",
+        "definition": "file://assets/dashboards/overview.json"
+      }
+    ]
+  }
+}

pkg/query-service/app/cloudintegrations/services/definitions/aws/api-gateway/overview.md

@@ -0,0 +1,3 @@
+### Monitor API Gateway with SigNoz
+
+Collect key API Gateway metrics and view them with an out of the box dashboard.

pkg/query-service/app/cloudintegrations/services/definitions/aws/dynamodb/integration.json

@@ -0,0 +1,394 @@
+{
+  "id": "dynamodb",
+  "title": "DynamoDB",
+  "icon": "file://icon.svg",
+  "overview": "file://overview.md",
+  "supported_signals": {
+    "metrics": true,
+    "logs": false
+  },
+  "data_collected": {
+    "metrics": [
+      {
+        "name": "aws_DynamoDB_AccountMaxReads_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxReads_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxReads_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxReads_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxTableLevelReads_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxTableLevelReads_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxTableLevelReads_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxTableLevelReads_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxTableLevelWrites_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxTableLevelWrites_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxTableLevelWrites_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxTableLevelWrites_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxWrites_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxWrites_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxWrites_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountMaxWrites_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountProvisionedReadCapacityUtilization_count",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountProvisionedReadCapacityUtilization_max",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountProvisionedReadCapacityUtilization_min",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountProvisionedReadCapacityUtilization_sum",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountProvisionedWriteCapacityUtilization_count",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountProvisionedWriteCapacityUtilization_max",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountProvisionedWriteCapacityUtilization_min",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_AccountProvisionedWriteCapacityUtilization_sum",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ConsumedReadCapacityUnits_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ConsumedReadCapacityUnits_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ConsumedReadCapacityUnits_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ConsumedReadCapacityUnits_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ConsumedWriteCapacityUnits_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ConsumedWriteCapacityUnits_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ConsumedWriteCapacityUnits_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ConsumedWriteCapacityUnits_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_MaxProvisionedTableReadCapacityUtilization_count",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_MaxProvisionedTableReadCapacityUtilization_max",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_MaxProvisionedTableReadCapacityUtilization_min",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_MaxProvisionedTableReadCapacityUtilization_sum",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_MaxProvisionedTableWriteCapacityUtilization_count",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_MaxProvisionedTableWriteCapacityUtilization_max",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_MaxProvisionedTableWriteCapacityUtilization_min",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_MaxProvisionedTableWriteCapacityUtilization_sum",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ReturnedItemCount_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ReturnedItemCount_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ReturnedItemCount_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ReturnedItemCount_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_SuccessfulRequestLatency_count",
+        "unit": "Milliseconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_SuccessfulRequestLatency_max",
+        "unit": "Milliseconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_SuccessfulRequestLatency_min",
+        "unit": "Milliseconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_SuccessfulRequestLatency_sum",
+        "unit": "Milliseconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ThrottledRequests_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ThrottledRequests_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ThrottledRequests_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_ThrottledRequests_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_UserErrors_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_UserErrors_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_UserErrors_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_UserErrors_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_WriteThrottleEvents_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_WriteThrottleEvents_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_WriteThrottleEvents_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_DynamoDB_WriteThrottleEvents_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      }
+    ]
+  },
+  "telemetry_collection_strategy": {
+    "aws_metrics": {
+      "cloudwatch_metric_stream_filters": [
+        {
+          "Namespace": "AWS/DynamoDB"
+        }
+      ]
+    }
+  },
+  "assets": {
+    "dashboards": [
+      {
+        "id": "overview",
+        "title": "DynamoDB Overview",
+        "description": "Overview of DynamoDB",
+        "image": "file://assets/dashboards/overview.png",
+        "definition": "file://assets/dashboards/overview.json"
+      }
+    ]
+  }
+}

pkg/query-service/app/cloudintegrations/services/definitions/aws/dynamodb/overview.md

@@ -0,0 +1,3 @@
+### Monitor DynamoDB with SigNoz
+
+Collect DynamoDB Key Metrics and view them with an out of the box dashboard.

pkg/query-service/app/cloudintegrations/services/definitions/aws/ec2/icon.svg

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg width="800px" height="800px" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="none">
+  <path fill="#9D5025" d="M1.702 2.98L1 3.312v9.376l.702.332 2.842-4.777L1.702 2.98z" />
+  <path fill="#F58536" d="M3.339 12.657l-1.637.363V2.98l1.637.353v9.324z" />
+  <path fill="#9D5025" d="M2.476 2.612l.863-.406 4.096 6.216-4.096 5.372-.863-.406V2.612z" />
+  <path fill="#F58536" d="M5.38 13.248l-2.041.546V2.206l2.04.548v10.494z" />
+  <path fill="#9D5025" d="M4.3 1.75l1.08-.512 6.043 7.864-6.043 5.66-1.08-.511V1.749z" />
+  <path fill="#F58536" d="M7.998 13.856l-2.618.906V1.238l2.618.908v11.71z" />
+  <path fill="#9D5025" d="M6.602.66L7.998 0l6.538 8.453L7.998 16l-1.396-.66V.66z" />
+  <path fill="#F58536" d="M15 12.686L7.998 16V0L15 3.314v9.372z" />
+</svg>

pkg/query-service/app/cloudintegrations/services/definitions/aws/ec2/integration.json

@@ -0,0 +1,518 @@
+{
+  "id": "ec2",
+  "title": "EC2",
+  "icon": "file://icon.svg",
+  "overview": "file://overview.md",
+  "supported_signals": {
+    "metrics": true,
+    "logs": false
+  },
+  "data_collected": {
+    "metrics": [
+      {
+        "name": "aws_EC2_CPUCreditBalance_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUCreditBalance_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUCreditBalance_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUCreditBalance_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUCreditUsage_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUCreditUsage_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUCreditUsage_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUCreditUsage_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUSurplusCreditBalance_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUSurplusCreditBalance_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUSurplusCreditBalance_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUSurplusCreditBalance_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUSurplusCreditsCharged_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUSurplusCreditsCharged_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUSurplusCreditsCharged_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUSurplusCreditsCharged_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUUtilization_count",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUUtilization_max",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUUtilization_min",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_CPUUtilization_sum",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSByteBalance__count",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSByteBalance__max",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSByteBalance__min",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSByteBalance__sum",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSIOBalance__count",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSIOBalance__max",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSIOBalance__min",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSIOBalance__sum",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSReadBytes_count",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSReadBytes_max",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSReadBytes_min",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSReadBytes_sum",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSReadOps_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSReadOps_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSReadOps_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSReadOps_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSWriteBytes_count",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSWriteBytes_max",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSWriteBytes_min",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSWriteBytes_sum",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSWriteOps_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSWriteOps_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSWriteOps_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_EBSWriteOps_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_MetadataNoToken_count",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_MetadataNoToken_max",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_MetadataNoToken_min",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_MetadataNoToken_sum",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkIn_count",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkIn_max",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkIn_min",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkIn_sum",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkOut_count",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkOut_max",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkOut_min",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkOut_sum",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkPacketsIn_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkPacketsIn_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkPacketsIn_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkPacketsIn_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkPacketsOut_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkPacketsOut_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkPacketsOut_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_NetworkPacketsOut_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_AttachedEBS_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_AttachedEBS_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_AttachedEBS_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_AttachedEBS_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_Instance_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_Instance_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_Instance_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_Instance_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_System_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_System_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_System_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_System_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_max",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_min",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "aws_EC2_StatusCheckFailed_sum",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      }
+    ],
+    "logs": []
+  },
+  "telemetry_collection_strategy": {
+    "aws_metrics": {
+      "cloudwatch_metric_stream_filters": [
+        {
+          "Namespace": "AWS/EC2"
+        },
+        {
+          "Namespace": "CWAgent"
+        }
+      ]
+    }
+  },
+  "assets": {
+    "dashboards": [
+      {
+        "id": "overview",
+        "title": "EC2 Overview",
+        "description": "Overview of EC2",
+        "image": "file://assets/dashboards/overview.png",
+        "definition": "file://assets/dashboards/overview.json"
+      }
+    ]
+  }
+}

pkg/query-service/app/cloudintegrations/services/definitions/aws/ec2/overview.md

@@ -0,0 +1,3 @@
+### Monitor EC2 with SigNoz
+
+Collect key EC2 metrics and view them with an out of the box dashboard.