chore: added fastpath function

ee/query-service/rules/manager.go

@@ -39,7 +39,6 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 			baserules.WithQueryParser(opts.ManagerOpts.QueryParser),
 			baserules.WithMetadataStore(opts.ManagerOpts.MetadataStore),
 			baserules.WithRuleStateHistoryModule(opts.ManagerOpts.RuleStateHistoryModule),
-			baserules.WithExternalURL(opts.ManagerOpts.ExternalURL),
 		)
 
 		if err != nil {
@@ -64,7 +63,6 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 			baserules.WithQueryParser(opts.ManagerOpts.QueryParser),
 			baserules.WithMetadataStore(opts.ManagerOpts.MetadataStore),
 			baserules.WithRuleStateHistoryModule(opts.ManagerOpts.RuleStateHistoryModule),
-			baserules.WithExternalURL(opts.ManagerOpts.ExternalURL),
 		)
 
 		if err != nil {
@@ -89,7 +87,6 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 			baserules.WithQueryParser(opts.ManagerOpts.QueryParser),
 			baserules.WithMetadataStore(opts.ManagerOpts.MetadataStore),
 			baserules.WithRuleStateHistoryModule(opts.ManagerOpts.RuleStateHistoryModule),
-			baserules.WithExternalURL(opts.ManagerOpts.ExternalURL),
 		)
 		if err != nil {
 			return task, err
@@ -149,7 +146,6 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
 			baserules.WithSQLStore(opts.SQLStore),
 			baserules.WithQueryParser(opts.ManagerOpts.QueryParser),
 			baserules.WithMetadataStore(opts.ManagerOpts.MetadataStore),
-			baserules.WithExternalURL(opts.ManagerOpts.ExternalURL),
 		)
 
 		if err != nil {
@@ -171,7 +167,6 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
 			baserules.WithSQLStore(opts.SQLStore),
 			baserules.WithQueryParser(opts.ManagerOpts.QueryParser),
 			baserules.WithMetadataStore(opts.ManagerOpts.MetadataStore),
-			baserules.WithExternalURL(opts.ManagerOpts.ExternalURL),
 		)
 
 		if err != nil {
@@ -191,7 +186,6 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
 			baserules.WithSQLStore(opts.SQLStore),
 			baserules.WithQueryParser(opts.ManagerOpts.QueryParser),
 			baserules.WithMetadataStore(opts.ManagerOpts.MetadataStore),
-			baserules.WithExternalURL(opts.ManagerOpts.ExternalURL),
 		)
 		if err != nil {
 			slog.Error("failed to prepare a new anomaly rule for test", "name", alertname, errors.Attr(err))

pkg/alertmanager/alertmanager.go

@@ -48,11 +48,6 @@ type Alertmanager interface {
 	// DeleteChannelByID deletes a channel for the organization.
 	DeleteChannelByID(context.Context, string, valuer.UUID) error
 
-	// Config returns the alertmanager provider configuration. It exposes
-	// global settings (e.g. the external URL) to consumers like the rule
-	// manager so they do not need the value to be wired through main.
-	Config() Config
-
 	// SetConfig sets the config for the organization.
 	SetConfig(context.Context, *alertmanagertypes.Config) error
 

pkg/alertmanager/alertmanagertest/alertmanager.go

@@ -8,7 +8,6 @@ import (
 	"context"
 	"net/http"
 
-	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/prometheus/alertmanager/config"
@@ -110,50 +109,6 @@ func (_c *MockAlertmanager_Collect_Call) RunAndReturn(run func(context1 context.
 	return _c
 }
 
-// Config provides a mock function for the type MockAlertmanager
-func (_mock *MockAlertmanager) Config() alertmanager.Config {
-	ret := _mock.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Config")
-	}
-
-	var r0 alertmanager.Config
-	if returnFunc, ok := ret.Get(0).(func() alertmanager.Config); ok {
-		r0 = returnFunc()
-	} else {
-		r0 = ret.Get(0).(alertmanager.Config)
-	}
-	return r0
-}
-
-// MockAlertmanager_Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Config'
-type MockAlertmanager_Config_Call struct {
-	*mock.Call
-}
-
-// Config is a helper method to define mock.On call
-func (_e *MockAlertmanager_Expecter) Config() *MockAlertmanager_Config_Call {
-	return &MockAlertmanager_Config_Call{Call: _e.mock.On("Config")}
-}
-
-func (_c *MockAlertmanager_Config_Call) Run(run func()) *MockAlertmanager_Config_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *MockAlertmanager_Config_Call) Return(config alertmanager.Config) *MockAlertmanager_Config_Call {
-	_c.Call.Return(config)
-	return _c
-}
-
-func (_c *MockAlertmanager_Config_Call) RunAndReturn(run func() alertmanager.Config) *MockAlertmanager_Config_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
 // CreateChannel provides a mock function for the type MockAlertmanager
 func (_mock *MockAlertmanager) CreateChannel(context1 context.Context, s string, v alertmanagertypes.Receiver) (*alertmanagertypes.Channel, error) {
 	ret := _mock.Called(context1, s, v)

pkg/alertmanager/signozalertmanager/provider.go

@@ -235,10 +235,6 @@ func (provider *provider) CreateChannel(ctx context.Context, orgID string, recei
 	return channel, nil
 }
 
-func (provider *provider) Config() alertmanager.Config {
-	return provider.config
-}
-
 func (provider *provider) SetConfig(ctx context.Context, config *alertmanagertypes.Config) error {
 	return provider.configStore.Set(ctx, config)
 }

pkg/modules/metricsexplorer/implmetricsexplorer/module.go

@@ -219,19 +219,25 @@ func (m *module) GetStats(ctx context.Context, orgID valuer.UUID, req *metricsex
 		return nil, err
 	}
 
-	filterWhereClause, err := m.buildFilterClause(ctx, req.Filter, req.Start, req.End)
-	if err != nil {
-		return nil, err
+	var (
+		metricStats []metricsexplorertypes.Stat
+		total       uint64
+		err         error
+	)
+
+	hasFilter := req.Filter != nil && strings.TrimSpace(req.Filter.Expression) != ""
+
+	if hasFilter {
+		var filterWhereClause *sqlbuilder.WhereClause
+		filterWhereClause, err = m.buildFilterClause(ctx, req.Filter, req.Start, req.End)
+		if err != nil {
+			return nil, err
+		}
+		metricStats, total, err = m.fetchMetricsStatsWithSamples(ctx, req, filterWhereClause, false, req.OrderBy)
+	} else {
+		metricStats, total, err = m.fetchMetricsStatsWithSamplesFastPath(ctx, req, false, req.OrderBy)
 	}
 
-	// Single query to get stats with samples, timeseries counts in required sorting order
-	metricStats, total, err := m.fetchMetricsStatsWithSamples(
-		ctx,
-		req,
-		filterWhereClause,
-		false,
-		req.OrderBy,
-	)
 	if err != nil {
 		return nil, err
 	}
@@ -268,21 +274,28 @@ func (m *module) GetTreemap(ctx context.Context, orgID valuer.UUID, req *metrics
 		return nil, err
 	}
 
+	hasFilter := req.Filter != nil && strings.TrimSpace(req.Filter.Expression) != ""
 	filterWhereClause, err := m.buildFilterClause(ctx, req.Filter, req.Start, req.End)
 	if err != nil {
 		return nil, err
 	}
 
+	var entries []metricsexplorertypes.TreemapEntry
+
 	resp := &metricsexplorertypes.TreemapResponse{}
 	switch req.Mode {
 	case metricsexplorertypes.TreemapModeSamples:
-		entries, err := m.computeSamplesTreemap(ctx, req, filterWhereClause)
+		if hasFilter {
+			entries, err = m.computeSamplesTreemap(ctx, req, filterWhereClause)
+		} else {
+			entries, err = m.computeSamplesTreemapFastPath(ctx, req)
+		}
 		if err != nil {
 			return nil, err
 		}
 		resp.Samples = entries
 	default: // TreemapModeTimeSeries
-		entries, err := m.computeTimeseriesTreemap(ctx, req, filterWhereClause)
+		entries, err = m.computeTimeseriesTreemap(ctx, req, filterWhereClause)
 		if err != nil {
 			return nil, err
 		}
@@ -1085,6 +1098,109 @@ func (m *module) fetchMetricsStatsWithSamples(
 	return metricStats, total, nil
 }
 
+func (m *module) fetchMetricsStatsWithSamplesFastPath(
+	ctx context.Context,
+	req *metricsexplorertypes.StatsRequest,
+	normalized bool,
+	orderBy *qbtypes.OrderBy,
+) ([]metricsexplorertypes.Stat, uint64, error) {
+	ctx = m.withMetricsExplorerContext(ctx, "fetchMetricsStatsWithSamplesFastPath")
+
+	start, end, distributedTsTable, localTsTable := telemetrymetrics.WhichTSTableToUse(uint64(req.Start), uint64(req.End), nil)
+	samplesTable := telemetrymetrics.WhichSamplesTableToUse(uint64(req.Start), uint64(req.End), metrictypes.UnspecifiedType, metrictypes.TimeAggregationUnspecified, nil)
+	countExp := telemetrymetrics.CountExpressionForSamplesTable(samplesTable)
+
+	// Timeseries counts per metric
+	tsSB := sqlbuilder.NewSelectBuilder()
+	tsSB.Select(
+		"metric_name",
+		"uniq(fingerprint) AS timeseries",
+	)
+	tsSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTsTable))
+	tsSB.Where(tsSB.Between("unix_milli", start, end))
+	tsSB.Where("NOT startsWith(metric_name, 'signoz')")
+	tsSB.Where(tsSB.E("__normalized", normalized))
+	tsSB.GroupBy("metric_name")
+
+	// Distinct metric_names from local TS table — narrows samples scan on its leading sort key
+	metricNamesSB := sqlbuilder.NewSelectBuilder()
+	metricNamesSB.Select("DISTINCT metric_name")
+	metricNamesSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localTsTable))
+	metricNamesSB.Where(metricNamesSB.Between("unix_milli", start, end))
+	metricNamesSB.Where("NOT startsWith(metric_name, 'signoz')")
+	metricNamesSB.Where(metricNamesSB.E("__normalized", normalized))
+
+	// Samples counts per metric
+	samplesSB := sqlbuilder.NewSelectBuilder()
+	samplesSB.Select(
+		"metric_name",
+		fmt.Sprintf("%s AS samples", countExp),
+	)
+	samplesSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, samplesTable))
+	samplesSB.Where(samplesSB.Between("unix_milli", req.Start, req.End))
+	samplesSB.Where("NOT startsWith(metric_name, 'signoz')")
+	samplesSB.Where(fmt.Sprintf("metric_name IN (%s)", samplesSB.Var(metricNamesSB)))
+	samplesSB.GroupBy("metric_name")
+
+	cteBuilder := sqlbuilder.With(
+		sqlbuilder.CTEQuery("__time_series_counts").As(tsSB),
+		sqlbuilder.CTEQuery("__sample_counts").As(samplesSB),
+	)
+
+	finalSB := cteBuilder.Select(
+		"COALESCE(ts.metric_name, s.metric_name) AS metric_name",
+		"COALESCE(ts.timeseries, 0) AS timeseries",
+		"COALESCE(s.samples, 0) AS samples",
+		"COUNT(*) OVER() AS total",
+	)
+	finalSB.From("__time_series_counts ts")
+	finalSB.JoinWithOption(sqlbuilder.FullOuterJoin, "__sample_counts s", "ts.metric_name = s.metric_name")
+	finalSB.Where("(COALESCE(ts.timeseries, 0) > 0 OR COALESCE(s.samples, 0) > 0)")
+
+	orderByColumn, orderDirection, err := getStatsOrderByColumn(orderBy)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	finalSB.OrderBy(
+		fmt.Sprintf("%s %s", orderByColumn, strings.ToUpper(orderDirection)),
+		"metric_name ASC",
+	)
+	finalSB.Limit(req.Limit)
+	finalSB.Offset(req.Offset)
+
+	query, args := finalSB.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	valueCtx := ctxtypes.SetClickhouseMaxThreads(ctx, m.config.TelemetryStore.Threads)
+	db := m.telemetryStore.ClickhouseDB()
+	rows, err := db.Query(valueCtx, query, args...)
+	if err != nil {
+		return nil, 0, errors.WrapInternalf(err, errors.CodeInternal, "failed to execute metrics stats with samples fastpath query")
+	}
+	defer rows.Close()
+
+	metricStats := make([]metricsexplorertypes.Stat, 0)
+	var total uint64
+
+	for rows.Next() {
+		var (
+			metricStat metricsexplorertypes.Stat
+			rowTotal   uint64
+		)
+		if err := rows.Scan(&metricStat.MetricName, &metricStat.TimeSeries, &metricStat.Samples, &rowTotal); err != nil {
+			return nil, 0, errors.WrapInternalf(err, errors.CodeInternal, "failed to scan metrics stats row")
+		}
+		metricStats = append(metricStats, metricStat)
+		total = rowTotal
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, 0, errors.WrapInternalf(err, errors.CodeInternal, "error iterating metrics stats rows")
+	}
+
+	return metricStats, total, nil
+}
+
 func (m *module) computeTimeseriesTreemap(ctx context.Context, req *metricsexplorertypes.TreemapRequest, filterWhereClause *sqlbuilder.WhereClause) ([]metricsexplorertypes.TreemapEntry, error) {
 	ctx = m.withMetricsExplorerContext(ctx, "computeTimeseriesTreemap")
 
@@ -1253,6 +1369,84 @@ func (m *module) computeSamplesTreemap(ctx context.Context, req *metricsexplorer
 	return entries, nil
 }
 
+func (m *module) computeSamplesTreemapFastPath(ctx context.Context, req *metricsexplorertypes.TreemapRequest) ([]metricsexplorertypes.TreemapEntry, error) {
+
+	ctx = m.withMetricsExplorerContext(ctx, "computeSamplesTreemapFastPath")
+
+	start, end, distributedTsTable, _ := telemetrymetrics.WhichTSTableToUse(uint64(req.Start), uint64(req.End), nil)
+	samplesTable := telemetrymetrics.WhichSamplesTableToUse(uint64(req.Start), uint64(req.End), metrictypes.UnspecifiedType, metrictypes.TimeAggregationUnspecified, nil)
+	countExp := telemetrymetrics.CountExpressionForSamplesTable(samplesTable)
+
+	candidateLimit := req.Limit + 50
+
+	metricCandidatesSB := sqlbuilder.NewSelectBuilder()
+	metricCandidatesSB.Select("metric_name")
+	metricCandidatesSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTsTable))
+	metricCandidatesSB.Where("NOT startsWith(metric_name, 'signoz')")
+	metricCandidatesSB.Where(metricCandidatesSB.E("__normalized", false))
+	metricCandidatesSB.Where(metricCandidatesSB.Between("unix_milli", start, end))
+	metricCandidatesSB.GroupBy("metric_name")
+	metricCandidatesSB.OrderBy("uniq(fingerprint) DESC")
+	metricCandidatesSB.Limit(candidateLimit)
+
+	totalSamplesSB := sqlbuilder.NewSelectBuilder()
+	totalSamplesSB.Select(fmt.Sprintf("%s AS total_samples", countExp))
+	totalSamplesSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, samplesTable))
+	totalSamplesSB.Where(totalSamplesSB.Between("unix_milli", req.Start, req.End))
+
+	sampleCountsSB := sqlbuilder.NewSelectBuilder()
+	sampleCountsSB.Select(
+		"metric_name",
+		fmt.Sprintf("%s AS samples", countExp),
+	)
+	sampleCountsSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, samplesTable))
+	sampleCountsSB.Where(sampleCountsSB.Between("unix_milli", req.Start, req.End))
+	sampleCountsSB.Where("metric_name GLOBAL IN (SELECT metric_name FROM __metric_candidates)")
+	sampleCountsSB.GroupBy("metric_name")
+
+	cteBuilder := sqlbuilder.With(
+		sqlbuilder.CTEQuery("__metric_candidates").As(metricCandidatesSB),
+		sqlbuilder.CTEQuery("__sample_counts").As(sampleCountsSB),
+		sqlbuilder.CTEQuery("__total_samples").As(totalSamplesSB),
+	)
+
+	finalSB := cteBuilder.Select(
+		"mc.metric_name",
+		"COALESCE(sc.samples, 0) AS samples",
+		"CASE WHEN ts.total_samples = 0 THEN 0 ELSE (COALESCE(sc.samples, 0) * 100.0 / ts.total_samples) END AS percentage",
+	)
+	finalSB.From("__metric_candidates mc")
+	finalSB.JoinWithOption(sqlbuilder.LeftJoin, "__sample_counts sc", "mc.metric_name = sc.metric_name")
+	finalSB.Join("__total_samples ts", "1=1")
+	finalSB.OrderBy("percentage DESC")
+	finalSB.Limit(req.Limit)
+
+	query, args := finalSB.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	valueCtx := ctxtypes.SetClickhouseMaxThreads(ctx, m.config.TelemetryStore.Threads)
+	db := m.telemetryStore.ClickhouseDB()
+	rows, err := db.Query(valueCtx, query, args...)
+	if err != nil {
+		return nil, errors.WrapInternalf(err, errors.CodeInternal, "failed to execute samples treemap fastpath query")
+	}
+	defer rows.Close()
+
+	entries := make([]metricsexplorertypes.TreemapEntry, 0)
+	for rows.Next() {
+		var treemapEntry metricsexplorertypes.TreemapEntry
+		if err := rows.Scan(&treemapEntry.MetricName, &treemapEntry.TotalValue, &treemapEntry.Percentage); err != nil {
+			return nil, errors.WrapInternalf(err, errors.CodeInternal, "failed to scan samples treemap row")
+		}
+		entries = append(entries, treemapEntry)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, errors.WrapInternalf(err, errors.CodeInternal, "error iterating samples treemap rows")
+	}
+
+	return entries, nil
+}
+
 // getMetricDataPoints returns the total number of data points (samples) for a metric.
 func (m *module) getMetricDataPoints(ctx context.Context, metricName string) (uint64, error) {
 	ctx = m.withMetricsExplorerContext(ctx, "getMetricDataPoints")

pkg/query-service/rules/base_rule.go

@@ -4,8 +4,6 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
-	"net/url"
-	"strings"
 	"sync"
 	"time"
 
@@ -25,7 +23,7 @@ type BaseRule struct {
 	id             string
 	name           string
 	orgID          valuer.UUID
-	externalURL    *url.URL
+	source         string
 	handledRestart bool
 
 	// Type of the rule
@@ -140,16 +138,6 @@ func WithRuleStateHistoryModule(module rulestatehistory.Module) RuleOption {
 	}
 }
 
-// WithExternalURL injects the alertmanager external URL. It is sourced from
-// SIGNOZ_ALERTMANAGER_SIGNOZ_EXTERNAL__URL via [alertmanager.Alertmanager.Config]
-// and used as the base for rule-related URLs (generator URL and related
-// logs/traces links) in alert notifications.
-func WithExternalURL(externalURL *url.URL) RuleOption {
-	return func(r *BaseRule) {
-		r.externalURL = externalURL
-	}
-}
-
 func NewBaseRule(id string, orgID valuer.UUID, p *ruletypes.PostableRule, opts ...RuleOption) (*BaseRule, error) {
 	threshold, err := p.RuleCondition.Thresholds.GetRuleThreshold()
 	if err != nil {
@@ -164,6 +152,7 @@ func NewBaseRule(id string, orgID valuer.UUID, p *ruletypes.PostableRule, opts .
 		id:                id,
 		orgID:             orgID,
 		name:              p.AlertName,
+		source:            p.Source,
 		typ:               p.AlertType,
 		ruleCondition:     p.RuleCondition,
 		evalWindow:        p.EvalWindow,
@@ -252,24 +241,7 @@ func (r *BaseRule) Annotations() ruletypes.Labels       { return r.annotations }
 func (r *BaseRule) PreferredChannels() []string         { return r.preferredChannels }
 
 func (r *BaseRule) GeneratorURL() string {
-	if r.externalURL == nil {
-		return ""
-	}
-	u := r.externalURL.JoinPath("alerts", "overview")
-	q := u.Query()
-	q.Set("ruleId", r.ID())
-	u.RawQuery = q.Encode()
-	return u.String()
-}
-
-// ExternalURLHost returns the configured alertmanager external URL as a string
-// (trailing slash trimmed). It is used as the host portion of rule-related URLs
-// (e.g. related logs/traces links) in alert notifications.
-func (r *BaseRule) ExternalURLHost() string {
-	if r.externalURL == nil {
-		return ""
-	}
-	return strings.TrimRight(r.externalURL.String(), "/")
+	return ruletypes.PrepareRuleGeneratorURL(r.ID(), r.source)
 }
 
 func (r *BaseRule) SelectedQuery(ctx context.Context) string {

pkg/query-service/rules/base_rule_test.go

@@ -3,7 +3,6 @@ package rules
 import (
 	"context"
 	"fmt"
-	"net/url"
 	"testing"
 	"time"
 
@@ -724,88 +723,6 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 	}
 }
 
-func TestBaseRule_ExternalURLHost(t *testing.T) {
-	mustParse := func(raw string) *url.URL {
-		u, err := url.Parse(raw)
-		require.NoError(t, err)
-		return u
-	}
-
-	tests := []struct {
-		name        string
-		externalURL *url.URL
-		want        string
-	}{
-		{name: "nil URL returns empty", externalURL: nil, want: ""},
-		{name: "default value returned as-is", externalURL: mustParse("http://localhost:8080"), want: "http://localhost:8080"},
-		{name: "configured https host", externalURL: mustParse("https://signoz.example.com"), want: "https://signoz.example.com"},
-		{name: "configured host with port", externalURL: mustParse("http://signoz.internal:3301"), want: "http://signoz.internal:3301"},
-		{name: "trailing slash is trimmed", externalURL: mustParse("https://signoz.example.com/"), want: "https://signoz.example.com"},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			p := createPostableRule(&ruletypes.AlertCompositeQuery{})
-			r, err := NewBaseRule("some-id", valuer.GenerateUUID(), &p, WithExternalURL(tc.externalURL))
-			if err != nil {
-				t.Errorf("unexpected error: %v", err)
-			}
-			require.Equal(t, tc.want, r.ExternalURLHost())
-		})
-	}
-}
-
-func TestBaseRule_GeneratorURL(t *testing.T) {
-	mustParse := func(raw string) *url.URL {
-		u, err := url.Parse(raw)
-		require.NoError(t, err)
-		return u
-	}
-
-	tests := []struct {
-		name        string
-		ruleID      string
-		externalURL *url.URL
-		want        string
-	}{
-		{
-			name:        "nil URL returns empty",
-			ruleID:      "abc",
-			externalURL: nil,
-			want:        "",
-		},
-		{
-			name:        "configured external URL",
-			ruleID:      "abc",
-			externalURL: mustParse("https://signoz.example.com"),
-			want:        "https://signoz.example.com/alerts/overview?ruleId=abc",
-		},
-		{
-			name:        "default external URL is used as-is",
-			ruleID:      "abc",
-			externalURL: mustParse("http://localhost:8080"),
-			want:        "http://localhost:8080/alerts/overview?ruleId=abc",
-		},
-		{
-			name:        "external URL with base path is preserved",
-			ruleID:      "abc",
-			externalURL: mustParse("https://signoz.example.com/signoz"),
-			want:        "https://signoz.example.com/signoz/alerts/overview?ruleId=abc",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			p := createPostableRule(&ruletypes.AlertCompositeQuery{})
-			r, err := NewBaseRule(tc.ruleID, valuer.GenerateUUID(), &p, WithExternalURL(tc.externalURL))
-			if err != nil {
-				t.Errorf("unexpected error: %v", err)
-			}
-			require.Equal(t, tc.want, r.GeneratorURL())
-		})
-	}
-}
-
 // labelsKey creates a deterministic string key from a labels map
 // This is used to group series by their unique label combinations
 func labelsKey(lbls []*qbtypes.Label) string {

pkg/query-service/rules/manager.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"log/slog"
-	"net/url"
 	"sort"
 	"strings"
 	"sync"
@@ -81,11 +80,6 @@ type ManagerOptions struct {
 
 	EvalDelay valuer.TextDuration
 
-	// ExternalURL is the alertmanager external URL.
-	// Rules use it as the host for generator URLs and related logs/traces
-	// links in alert notifications.
-	ExternalURL *url.URL
-
 	RuleStateHistoryModule rulestatehistory.Module
 
 	PrepareTaskFunc     func(opts PrepareTaskOptions) (Task, error)
@@ -161,7 +155,6 @@ func defaultPrepareTaskFunc(opts PrepareTaskOptions) (Task, error) {
 			WithQueryParser(opts.ManagerOpts.QueryParser),
 			WithMetadataStore(opts.ManagerOpts.MetadataStore),
 			WithRuleStateHistoryModule(opts.ManagerOpts.RuleStateHistoryModule),
-			WithExternalURL(opts.ManagerOpts.ExternalURL),
 		)
 		if err != nil {
 			return task, err
@@ -185,7 +178,6 @@ func defaultPrepareTaskFunc(opts PrepareTaskOptions) (Task, error) {
 			WithQueryParser(opts.ManagerOpts.QueryParser),
 			WithMetadataStore(opts.ManagerOpts.MetadataStore),
 			WithRuleStateHistoryModule(opts.ManagerOpts.RuleStateHistoryModule),
-			WithExternalURL(opts.ManagerOpts.ExternalURL),
 		)
 		if err != nil {
 			return task, err

pkg/query-service/rules/test_notification.go

@@ -54,7 +54,6 @@ func defaultTestNotification(opts PrepareTestRuleOptions) (int, error) {
 			WithSQLStore(opts.SQLStore),
 			WithQueryParser(opts.ManagerOpts.QueryParser),
 			WithMetadataStore(opts.ManagerOpts.MetadataStore),
-			WithExternalURL(opts.ManagerOpts.ExternalURL),
 		)
 
 		if err != nil {
@@ -76,7 +75,6 @@ func defaultTestNotification(opts PrepareTestRuleOptions) (int, error) {
 			WithSQLStore(opts.SQLStore),
 			WithQueryParser(opts.ManagerOpts.QueryParser),
 			WithMetadataStore(opts.ManagerOpts.MetadataStore),
-			WithExternalURL(opts.ManagerOpts.ExternalURL),
 		)
 
 		if err != nil {

pkg/query-service/rules/threshold_rule.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"log/slog"
+	"net/url"
 	"reflect"
 	"time"
 
@@ -54,6 +55,17 @@ func NewThresholdRule(
 	}, nil
 }
 
+func (r *ThresholdRule) hostFromSource() string {
+	parsedURL, err := url.Parse(r.source)
+	if err != nil {
+		return ""
+	}
+	if parsedURL.Port() != "" {
+		return fmt.Sprintf("%s://%s:%s", parsedURL.Scheme, parsedURL.Hostname(), parsedURL.Port())
+	}
+	return fmt.Sprintf("%s://%s", parsedURL.Scheme, parsedURL.Hostname())
+}
+
 func (r *ThresholdRule) Type() ruletypes.RuleType {
 	return ruletypes.RuleTypeThreshold
 }
@@ -338,15 +350,15 @@ func (r *ThresholdRule) Eval(ctx context.Context, ts time.Time) (int, error) {
 		switch r.typ {
 		case ruletypes.AlertTypeTraces:
 			link := r.prepareLinksToTraces(ctx, ts, smpl.Metric)
-			if link != "" && r.ExternalURLHost() != "" {
-				r.logger.InfoContext(ctx, "adding traces link to annotations", slog.String("annotation.link", fmt.Sprintf("%s/traces-explorer?%s", r.ExternalURLHost(), link)))
-				annotations = append(annotations, ruletypes.Label{Name: ruletypes.AnnotationRelatedTraces, Value: fmt.Sprintf("%s/traces-explorer?%s", r.ExternalURLHost(), link)})
+			if link != "" && r.hostFromSource() != "" {
+				r.logger.InfoContext(ctx, "adding traces link to annotations", slog.String("annotation.link", fmt.Sprintf("%s/traces-explorer?%s", r.hostFromSource(), link)))
+				annotations = append(annotations, ruletypes.Label{Name: ruletypes.AnnotationRelatedTraces, Value: fmt.Sprintf("%s/traces-explorer?%s", r.hostFromSource(), link)})
 			}
 		case ruletypes.AlertTypeLogs:
 			link := r.prepareLinksToLogs(ctx, ts, smpl.Metric)
-			if link != "" && r.ExternalURLHost() != "" {
-				r.logger.InfoContext(ctx, "adding logs link to annotations", slog.String("annotation.link", fmt.Sprintf("%s/logs/logs-explorer?%s", r.ExternalURLHost(), link)))
-				annotations = append(annotations, ruletypes.Label{Name: ruletypes.AnnotationRelatedLogs, Value: fmt.Sprintf("%s/logs/logs-explorer?%s", r.ExternalURLHost(), link)})
+			if link != "" && r.hostFromSource() != "" {
+				r.logger.InfoContext(ctx, "adding logs link to annotations", slog.String("annotation.link", fmt.Sprintf("%s/logs/logs-explorer?%s", r.hostFromSource(), link)))
+				annotations = append(annotations, ruletypes.Label{Name: ruletypes.AnnotationRelatedLogs, Value: fmt.Sprintf("%s/logs/logs-explorer?%s", r.hostFromSource(), link)})
 			}
 		}
 

pkg/ruler/signozruler/provider.go

@@ -57,7 +57,6 @@ func NewFactory(
 			Logger:                 providerSettings.Logger,
 			Cache:                  cache,
 			EvalDelay:              valuer.MustParseTextDuration(config.EvalDelay.String()),
-			ExternalURL:            alertmanager.Config().Signoz.ExternalURL,
 			PrepareTaskFunc:        prepareTaskFunc,
 			PrepareTestRuleFunc:    prepareTestRuleFunc,
 			Alertmanager:           alertmanager,

pkg/types/ruletypes/alerting.go

@@ -2,7 +2,10 @@ package ruletypes
 
 import (
 	"encoding/json"
+	"fmt"
+	"net/url"
 	"sort"
+	"strings"
 	"time"
 
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
@@ -188,3 +191,35 @@ func (rc *RuleCondition) String() string {
 	return string(data)
 }
 
+// PrepareRuleGeneratorURL creates an appropriate url for the rule. The URL is
+// sent in Slack messages as well as to other systems and allows backtracking
+// to the rule definition from the third party systems.
+func PrepareRuleGeneratorURL(ruleID string, source string) string {
+	if source == "" {
+		return source
+	}
+
+	// check if source is a valid url
+	parsedSource, err := url.Parse(source)
+	if err != nil {
+		return ""
+	}
+	// since we capture window.location when a new rule is created
+	// we end up with rulesource host:port/alerts/new. in this case
+	// we want to replace new with rule id parameter
+
+	hasNew := strings.LastIndex(source, "new")
+	if hasNew > -1 {
+		ruleURL := fmt.Sprintf("%sedit?ruleId=%s", source[0:hasNew], ruleID)
+		return ruleURL
+	}
+
+	// The source contains the encoded query, start and end time
+	// and other parameters. We don't want to include them in the generator URL
+	// mainly to keep the URL short and lower the alert body contents
+	// The generator URL with /alerts/edit?ruleId= is enough
+	if parsedSource.Port() != "" {
+		return fmt.Sprintf("%s://%s:%s/alerts/edit?ruleId=%s", parsedSource.Scheme, parsedSource.Hostname(), parsedSource.Port(), ruleID)
+	}
+	return fmt.Sprintf("%s://%s/alerts/edit?ruleId=%s", parsedSource.Scheme, parsedSource.Hostname(), ruleID)
+}