Skip to content

SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.

feat(ruler): add clone alert rule API (#13093)

Nikhil Mantri4f3e7fa50e03
diff --git a/docs/api/openapi.yml b/docs/api/openapi.yml
index f4f6d76e4d..3ae26462a4 100644
--- a/docs/api/openapi.yml
+++ b/docs/api/openapi.yml
@@ -25008,6 +25008,75 @@ paths:
tags:
- rules
x-signoz-stability: alpha
+ /api/v2/rules/{id}/clone:
+ post:
+ deprecated: false
+ description: This endpoint creates a new alert rule from the stored definition
+ of an existing one. The clone keeps every modeled field of the source, including
+ its enabled/disabled state, and gets the source's name suffixed with " - Copy"
+ (or a bumped " - Copy (n)" counter when the source is itself a copy). The
+ clone is owned by the caller.
+ operationId: CloneRuleByID
+ parameters:
+ - in: path
+ name: id
+ required: true
+ schema:
+ type: string
+ responses:
+ "201":
+ content:
+ application/json:
+ schema:
+ properties:
+ data:
+ $ref: '#/components/schemas/RuletypesRule'
+ status:
+ type: string
+ required:
+ - status
+ - data
+ type: object
+ description: Created
+ "400":
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/RenderErrorResponse'
+ description: Bad Request
+ "401":
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/RenderErrorResponse'
+ description: Unauthorized
+ "403":
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/RenderErrorResponse'
+ description: Forbidden
+ "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:
+ - EDITOR
+ - tokenizer:
+ - EDITOR
+ summary: Clone alert rule
+ tags:
+ - rules
+ x-signoz-stability: alpha
/api/v2/rules/{id}/history/filter_keys:
get:
deprecated: false
diff --git a/ee/query-service/rules/anomaly.go b/ee/query-service/rules/anomaly.go
index 2219c6ed96..6387b5b31e 100644
--- a/ee/query-service/rules/anomaly.go
+++ b/ee/query-service/rules/anomaly.go
@@ -423,7 +423,7 @@ func (r *AnomalyRule) Eval(ctx context.Context, ts time.Time) (int, error) {
func (r *AnomalyRule) String() string {
ar := ruletypes.PostableRule{
- AlertName: r.Name(),
+ AlertName: valuer.NewDisplayName(r.Name()),
RuleCondition: r.Condition(),
EvalWindow: r.EvalWindow(),
Labels: r.Labels().Map(),
diff --git a/ee/query-service/rules/anomaly_test.go b/ee/query-service/rules/anomaly_test.go
index f44f478ddc..a290c8d65d 100644
--- a/ee/query-service/rules/anomaly_test.go
+++ b/ee/query-service/rules/anomaly_test.go
@@ -46,7 +46,7 @@ func TestAnomalyRule_NoData_AlertOnAbsent(t *testing.T) {
target := 500.0
postableRule := ruletypes.PostableRule{
- AlertName: "Test anomaly no data",
+ AlertName: valuer.NewDisplayName("Test anomaly no data"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeAnomaly,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -149,7 +149,7 @@ func TestAnomalyRule_NoData_AbsentFor(t *testing.T) {
target := 500.0
postableRule := ruletypes.PostableRule{
- AlertName: "Test anomaly no data with AbsentFor",
+ AlertName: valuer.NewDisplayName("Test anomaly no data with AbsentFor"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeAnomaly,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
diff --git a/ee/query-service/rules/manager.go b/ee/query-service/rules/manager.go
index 9619b53bb8..50122c3308 100644
--- a/ee/query-service/rules/manager.go
+++ b/ee/query-service/rules/manager.go
@@ -13,6 +13,7 @@ import (
"github.com/SigNoz/signoz/pkg/errors"
baserules "github.com/SigNoz/signoz/pkg/query-service/rules"
"github.com/SigNoz/signoz/pkg/types/ruletypes"
+ "github.com/SigNoz/signoz/pkg/valuer"
)
func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error) {
@@ -118,7 +119,7 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
}
parsedRule := opts.Rule
- var alertname = parsedRule.AlertName
+ var alertname = parsedRule.AlertName.StringValue()
if alertname == "" {
// alertname is not mandatory for testing, so picking
// a random string here
@@ -126,7 +127,7 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
}
// append name to indicate this is test alert
- parsedRule.AlertName = fmt.Sprintf("%s%s", alertname, ruletypes.TestAlertPostFix)
+ parsedRule.AlertName = valuer.NewDisplayName(fmt.Sprintf("%s%s", alertname, ruletypes.TestAlertPostFix))
var rule baserules.Rule
var err error
diff --git a/frontend/src/api/generated/services/rules/index.ts b/frontend/src/api/generated/services/rules/index.ts
index ca6a99faac..95c7d50545 100644
--- a/frontend/src/api/generated/services/rules/index.ts
+++ b/frontend/src/api/generated/services/rules/index.ts
@@ -18,6 +18,8 @@ import type {
} from 'react-query';
import type {
+ CloneRuleByID201,
+ CloneRuleByIDPathParameters,
CreateRule201,
CreateRuleView201,
DeleteRuleByIDPathParameters,
@@ -963,6 +965,85 @@ export const useUpdateRuleByID = <
> => {
return useMutation(getUpdateRuleByIDMutationOptions(options));
};
+/**
+ * This endpoint creates a new alert rule from the stored definition of an existing one. The clone keeps every modeled field of the source, including its enabled/disabled state, and gets the source's name suffixed with " - Copy" (or a bumped " - Copy (n)" counter when the source is itself a copy). The clone is owned by the caller.
+ * @summary Clone alert rule
+ */
+export const cloneRuleByID = (
+ { id }: CloneRuleByIDPathParameters,
+ signal?: AbortSignal,
+) => {
+ return GeneratedAPIInstance<CloneRuleByID201>({
+ url: `/api/v2/rules/${id}/clone`,
+ method: 'POST',
+ signal,
+ });
+};
+
+export const getCloneRuleByIDMutationOptions = <
+ TError = ErrorType<RenderErrorResponseDTO>,
+ TContext = unknown,
+>(options?: {
+ mutation?: UseMutationOptions<
+ Awaited<ReturnType<typeof cloneRuleByID>>,
+ TError,
+ { pathParams: CloneRuleByIDPathParameters },
+ TContext
+ >;
+}): UseMutationOptions<
+ Awaited<ReturnType<typeof cloneRuleByID>>,
+ TError,
+ { pathParams: CloneRuleByIDPathParameters },
+ TContext
+> => {
+ const mutationKey = ['cloneRuleByID'];
+ 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 cloneRuleByID>>,
+ { pathParams: CloneRuleByIDPathParameters }
+ > = (props) => {
+ const { pathParams } = props ?? {};
+
+ return cloneRuleByID(pathParams);
+ };
+
+ return { mutationFn, ...mutationOptions };
+};
+
+export type CloneRuleByIDMutationResult = NonNullable<
+ Awaited<ReturnType<typeof cloneRuleByID>>
+>;
+
+export type CloneRuleByIDMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Clone alert rule
+ */
+export const useCloneRuleByID = <
+ TError = ErrorType<RenderErrorResponseDTO>,
+ TContext = unknown,
+>(options?: {
+ mutation?: UseMutationOptions<
+ Awaited<ReturnType<typeof cloneRuleByID>>,
+ TError,
+ { pathParams: CloneRuleByIDPathParameters },
+ TContext
+ >;
+}): UseMutationResult<
+ Awaited<ReturnType<typeof cloneRuleByID>>,
+ TError,
+ { pathParams: CloneRuleByIDPathParameters },
+ TContext
+> => {
+ return useMutation(getCloneRuleByIDMutationOptions(options));
+};
/**
* Returns distinct label keys from rule history entries for the selected range.
* @summary Get rule history filter keys
diff --git a/frontend/src/api/generated/services/sigNoz.schemas.ts b/frontend/src/api/generated/services/sigNoz.schemas.ts
index 101199258c..7d660a0fad 100644
--- a/frontend/src/api/generated/services/sigNoz.schemas.ts
+++ b/frontend/src/api/generated/services/sigNoz.schemas.ts
@@ -14612,6 +14612,17 @@ export type PatchRuleByID200 = {
export type UpdateRuleByIDPathParameters = {
id: string;
};
+export type CloneRuleByIDPathParameters = {
+ id: string;
+};
+export type CloneRuleByID201 = {
+ data: RuletypesRuleDTO;
+ /**
+ * @type string
+ */
+ status: string;
+};
+
export type GetRuleHistoryFilterKeysPathParameters = {
id: string;
};
diff --git a/pkg/apiserver/signozapiserver/ruler.go b/pkg/apiserver/signozapiserver/ruler.go
index ffdced466e..be4fe131b1 100644
--- a/pkg/apiserver/signozapiserver/ruler.go
+++ b/pkg/apiserver/signozapiserver/ruler.go
@@ -71,6 +71,20 @@ func (provider *provider) addRulerRoutes(router *mux.Router) error {
return err
}
+ if err := router.Handle("/api/v2/rules/{id}/clone", handler.New(provider.authzMiddleware.EditAccess(provider.rulerHandler.CloneRuleByID), handler.OpenAPIDef{
+ ID: "CloneRuleByID",
+ Tags: []string{"rules"},
+ Summary: "Clone alert rule",
+ Description: "This endpoint creates a new alert rule from the stored definition of an existing one. The clone keeps every modeled field of the source, including its enabled/disabled state, and gets the source's name suffixed with \" - Copy\" (or a bumped \" - Copy (n)\" counter when the source is itself a copy). The clone is owned by the caller.",
+ Response: new(ruletypes.Rule),
+ ResponseContentType: "application/json",
+ SuccessStatusCode: http.StatusCreated,
+ ErrorStatusCodes: []int{http.StatusBadRequest, http.StatusNotFound},
+ SecuritySchemes: newSecuritySchemes(types.RoleEditor),
+ })).Methods(http.MethodPost).GetError(); err != nil {
+ return err
+ }
+
if err := router.Handle("/api/v2/rules/{id}", handler.New(provider.authzMiddleware.EditAccess(provider.rulerHandler.UpdateRuleByID), handler.OpenAPIDef{
ID: "UpdateRuleByID",
Tags: []string{"rules"},
diff --git a/pkg/query-service/rules/base_rule.go b/pkg/query-service/rules/base_rule.go
index 610e7f921a..db8643c2cc 100644
--- a/pkg/query-service/rules/base_rule.go
+++ b/pkg/query-service/rules/base_rule.go
@@ -159,7 +159,7 @@ func NewBaseRule(
id: id,
orgID: orgID,
externalURL: externalURL,
- name: p.AlertName,
+ name: p.AlertName.StringValue(),
typ: p.AlertType,
ruleCondition: p.RuleCondition,
evalWindow: p.EvalWindow,
diff --git a/pkg/query-service/rules/base_rule_test.go b/pkg/query-service/rules/base_rule_test.go
index c78e132654..1512c55e70 100644
--- a/pkg/query-service/rules/base_rule_test.go
+++ b/pkg/query-service/rules/base_rule_test.go
@@ -126,7 +126,7 @@ func mergeFirstSeenMaps(maps ...map[telemetrytypes.MetricMetadataLookupKey]int64
// createPostableRule creates a PostableRule with the given CompositeQuery
func createPostableRule(compositeQuery *ruletypes.AlertCompositeQuery) ruletypes.PostableRule {
return ruletypes.PostableRule{
- AlertName: "Test Rule",
+ AlertName: valuer.NewDisplayName("Test Rule"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{
diff --git a/pkg/query-service/rules/manager.go b/pkg/query-service/rules/manager.go
index ce5d91d79e..a7d6a3f095 100644
--- a/pkg/query-service/rules/manager.go
+++ b/pkg/query-service/rules/manager.go
@@ -546,17 +546,30 @@ func (m *Manager) deleteTask(taskName string) {
// CreateRule stores rule def into db and also
// starts an executor for the rule, unless the rule is disabled
func (m *Manager) CreateRule(ctx context.Context, ruleStr string) (*ruletypes.GettableRule, error) {
- claims, err := authtypes.ClaimsFromContext(ctx)
+ parsedRule := ruletypes.PostableRule{}
+ if err := json.Unmarshal([]byte(ruleStr), &parsedRule); err != nil {
+ return nil, err
+ }
+
+ return m.createRule(ctx, parsedRule, ruleStr)
+}
+
+func (m *Manager) CreatePostableRule(ctx context.Context, rule *ruletypes.PostableRule) (*ruletypes.GettableRule, error) {
+ data, err := json.Marshal(rule)
if err != nil {
return nil, err
}
- orgID, err := valuer.NewUUID(claims.OrgID)
+ return m.createRule(ctx, *rule, string(data))
+}
+
+func (m *Manager) createRule(ctx context.Context, parsedRule ruletypes.PostableRule, data string) (*ruletypes.GettableRule, error) {
+ claims, err := authtypes.ClaimsFromContext(ctx)
if err != nil {
return nil, err
}
- parsedRule := ruletypes.PostableRule{}
- err = json.Unmarshal([]byte(ruleStr), &parsedRule)
+
+ orgID, err := valuer.NewUUID(claims.OrgID)
if err != nil {
return nil, err
}
@@ -579,7 +592,7 @@ func (m *Manager) CreateRule(ctx context.Context, ruleStr string) (*ruletypes.Ge
CreatedBy: claims.Email,
UpdatedBy: claims.Email,
},
- Data: ruleStr,
+ Data: data,
OrgID: claims.OrgID,
}
@@ -1106,7 +1119,7 @@ func (m *Manager) TestNotification(ctx context.Context, orgID valuer.UUID, ruleS
parsedRule.NotificationSettings.GroupBy = append(parsedRule.NotificationSettings.GroupBy, ruletypes.LabelThresholdName)
}
config := parsedRule.NotificationSettings.GetAlertManagerNotificationConfig()
- err = m.alertmanager.SetNotificationConfig(ctx, orgID, parsedRule.AlertName, &config)
+ err = m.alertmanager.SetNotificationConfig(ctx, orgID, parsedRule.AlertName.StringValue(), &config)
if err != nil {
return 0, err
}
diff --git a/pkg/query-service/rules/manager_test_data.go b/pkg/query-service/rules/manager_test_data.go
index 2aced39f9f..1e8c872468 100644
--- a/pkg/query-service/rules/manager_test_data.go
+++ b/pkg/query-service/rules/manager_test_data.go
@@ -36,7 +36,7 @@ type PromRuleTestCase struct {
// ThresholdRuleAtLeastOnceValueAbove creates a PostableRule for threshold rule test notifications
func ThresholdRuleAtLeastOnceValueAbove(target float64, recovery *float64) ruletypes.PostableRule {
return ruletypes.PostableRule{
- AlertName: "test-alert",
+ AlertName: valuer.NewDisplayName("test-alert"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -95,7 +95,7 @@ func ThresholdRuleAtLeastOnceValueAbove(target float64, recovery *float64) rulet
// BuildPromAtLeastOnceValueAbove creates a PostableRule for PromQL rule test notifications
func BuildPromAtLeastOnceValueAbove(target float64, recovery *float64) ruletypes.PostableRule {
return ruletypes.PostableRule{
- AlertName: "test-prom-alert",
+ AlertName: valuer.NewDisplayName("test-prom-alert"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeProm,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
diff --git a/pkg/query-service/rules/prom_rule.go b/pkg/query-service/rules/prom_rule.go
index 701cb77f9c..5ac3fcece8 100644
--- a/pkg/query-service/rules/prom_rule.go
+++ b/pkg/query-service/rules/prom_rule.go
@@ -359,7 +359,7 @@ func (r *PromRule) Eval(ctx context.Context, ts time.Time) (int, error) {
func (r *PromRule) String() string {
ar := ruletypes.PostableRule{
- AlertName: r.name,
+ AlertName: valuer.NewDisplayName(r.name),
RuleCondition: r.ruleCondition,
EvalWindow: r.evalWindow,
Labels: r.labels.Map(),
diff --git a/pkg/query-service/rules/prom_rule_test.go b/pkg/query-service/rules/prom_rule_test.go
index 56006794fa..89bdbb78a7 100644
--- a/pkg/query-service/rules/prom_rule_test.go
+++ b/pkg/query-service/rules/prom_rule_test.go
@@ -35,7 +35,7 @@ func getVectorValues(vectors []ruletypes.Sample) []float64 {
func TestPromRuleEval(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "Test Rule",
+ AlertName: valuer.NewDisplayName("Test Rule"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeProm,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -746,7 +746,7 @@ func TestPromRuleUnitCombinations(t *testing.T) {
evalTime := baseTime.Add(5 * time.Minute)
postableRule := ruletypes.PostableRule{
- AlertName: "Units test",
+ AlertName: valuer.NewDisplayName("Units test"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeProm,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -914,7 +914,7 @@ func TestPromRuleUnitCombinations(t *testing.T) {
Kind: ruletypes.BasicThresholdKind,
Spec: ruletypes.BasicRuleThresholds{
{
- Name: postableRule.AlertName,
+ Name: postableRule.AlertName.StringValue(),
TargetValue: &c.target,
TargetUnit: c.targetUnit,
MatchType: c.matchType,
@@ -962,7 +962,7 @@ func TestPromRuleNoData(t *testing.T) {
evalTime := baseTime.Add(5 * time.Minute)
postableRule := ruletypes.PostableRule{
- AlertName: "No data test",
+ AlertName: valuer.NewDisplayName("No data test"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeProm,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -1019,7 +1019,7 @@ func TestPromRuleNoData(t *testing.T) {
Kind: ruletypes.BasicThresholdKind,
Spec: ruletypes.BasicRuleThresholds{
{
- Name: postableRule.AlertName,
+ Name: postableRule.AlertName.StringValue(),
TargetValue: &target,
MatchType: ruletypes.AtleastOnce,
CompareOperator: ruletypes.ValueIsEq,
@@ -1062,7 +1062,7 @@ func TestMultipleThresholdPromRule(t *testing.T) {
evalTime := baseTime.Add(5 * time.Minute)
postableRule := ruletypes.PostableRule{
- AlertName: "Multiple threshold test",
+ AlertName: valuer.NewDisplayName("Multiple threshold test"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeProm,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -1261,7 +1261,7 @@ func TestPromRule_NoData(t *testing.T) {
evalTime := time.Now()
postableRule := ruletypes.PostableRule{
- AlertName: "Test no data",
+ AlertName: valuer.NewDisplayName("Test no data"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeProm,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -1357,7 +1357,7 @@ func TestPromRule_NoData_AbsentFor(t *testing.T) {
target := 500.0
postableRule := ruletypes.PostableRule{
- AlertName: "Test no data with AbsentFor",
+ AlertName: valuer.NewDisplayName("Test no data with AbsentFor"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeProm,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -1483,7 +1483,7 @@ func TestPromRuleEval_RequireMinPoints(t *testing.T) {
lookBackDelta := time.Minute
postableRule := ruletypes.PostableRule{
- AlertName: "Unit test",
+ AlertName: valuer.NewDisplayName("Unit test"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeProm,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -1572,7 +1572,7 @@ func TestPromRuleEval_RequireMinPoints(t *testing.T) {
Kind: ruletypes.BasicThresholdKind,
Spec: ruletypes.BasicRuleThresholds{
{
- Name: postableRule.AlertName,
+ Name: postableRule.AlertName.StringValue(),
TargetValue: rc.Target,
MatchType: rc.MatchType,
CompareOperator: rc.CompareOperator,
diff --git a/pkg/query-service/rules/test_notification.go b/pkg/query-service/rules/test_notification.go
index 6a8b836fb8..6271dba912 100644
--- a/pkg/query-service/rules/test_notification.go
+++ b/pkg/query-service/rules/test_notification.go
@@ -11,6 +11,7 @@ import (
"github.com/SigNoz/signoz/pkg/errors"
ruletypes "github.com/SigNoz/signoz/pkg/types/ruletypes"
+ "github.com/SigNoz/signoz/pkg/valuer"
)
// TestNotification prepares a dummy rule for given rule parameters and
@@ -23,7 +24,7 @@ func defaultTestNotification(opts PrepareTestRuleOptions) (int, error) {
}
parsedRule := opts.Rule
- var alertname = parsedRule.AlertName
+ var alertname = parsedRule.AlertName.StringValue()
if alertname == "" {
// alertname is not mandatory for testing, so picking
// a random string here
@@ -31,7 +32,7 @@ func defaultTestNotification(opts PrepareTestRuleOptions) (int, error) {
}
// append name to indicate this is test alert
- parsedRule.AlertName = fmt.Sprintf("%s%s", alertname, ruletypes.TestAlertPostFix)
+ parsedRule.AlertName = valuer.NewDisplayName(fmt.Sprintf("%s%s", alertname, ruletypes.TestAlertPostFix))
var rule Rule
var err error
diff --git a/pkg/query-service/rules/threshold_rule.go b/pkg/query-service/rules/threshold_rule.go
index a34edd9067..b4cb8a274b 100644
--- a/pkg/query-service/rules/threshold_rule.go
+++ b/pkg/query-service/rules/threshold_rule.go
@@ -468,7 +468,7 @@ func (r *ThresholdRule) Eval(ctx context.Context, ts time.Time) (int, error) {
func (r *ThresholdRule) String() string {
ar := ruletypes.PostableRule{
- AlertName: r.name,
+ AlertName: valuer.NewDisplayName(r.name),
RuleCondition: r.ruleCondition,
EvalWindow: r.evalWindow,
Labels: r.labels.Map(),
diff --git a/pkg/query-service/rules/threshold_rule_test.go b/pkg/query-service/rules/threshold_rule_test.go
index 5c0bb780c2..84de20d651 100644
--- a/pkg/query-service/rules/threshold_rule_test.go
+++ b/pkg/query-service/rules/threshold_rule_test.go
@@ -26,7 +26,7 @@ import (
func TestThresholdRuleEvalWithoutRecoveryTarget(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "Eval test without recovery target",
+ AlertName: valuer.NewDisplayName("Eval test without recovery target"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -145,7 +145,7 @@ func TestNormalizeLabelName(t *testing.T) {
func TestPrepareParamsForLogs(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "Tricky Condition Tests",
+ AlertName: valuer.NewDisplayName("Tricky Condition Tests"),
AlertType: ruletypes.AlertTypeLogs,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -210,7 +210,7 @@ func TestPrepareParamsForLogs(t *testing.T) {
func TestPrepareParamsForLogsFilterExpression(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "Tricky Condition Tests",
+ AlertName: valuer.NewDisplayName("Tricky Condition Tests"),
AlertType: ruletypes.AlertTypeLogs,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -275,7 +275,7 @@ func TestPrepareParamsForLogsFilterExpression(t *testing.T) {
func TestPrepareParamsForTracesFilterExpression(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "Tricky Condition Tests",
+ AlertName: valuer.NewDisplayName("Tricky Condition Tests"),
AlertType: ruletypes.AlertTypeTraces,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -340,7 +340,7 @@ func TestPrepareParamsForTracesFilterExpression(t *testing.T) {
func TestPrepareParamsForTraces(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "Links to traces test",
+ AlertName: valuer.NewDisplayName("Links to traces test"),
AlertType: ruletypes.AlertTypeTraces,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -406,7 +406,7 @@ func TestPrepareParamsForTraces(t *testing.T) {
func TestThresholdRuleLabelNormalization(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "Tricky Condition Tests",
+ AlertName: valuer.NewDisplayName("Tricky Condition Tests"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -511,7 +511,7 @@ func TestThresholdRuleLabelNormalization(t *testing.T) {
func TestThresholdRuleUnitCombinations(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "Units test",
+ AlertName: valuer.NewDisplayName("Units test"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -662,7 +662,7 @@ func TestThresholdRuleUnitCombinations(t *testing.T) {
Kind: ruletypes.BasicThresholdKind,
Spec: ruletypes.BasicRuleThresholds{
{
- Name: postableRule.AlertName,
+ Name: postableRule.AlertName.StringValue(),
TargetValue: &c.target,
TargetUnit: c.targetUnit,
MatchType: c.matchType,
@@ -704,7 +704,7 @@ func TestThresholdRuleUnitCombinations(t *testing.T) {
func TestThresholdRuleNoData(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "No data test",
+ AlertName: valuer.NewDisplayName("No data test"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -771,7 +771,7 @@ func TestThresholdRuleNoData(t *testing.T) {
Kind: ruletypes.BasicThresholdKind,
Spec: ruletypes.BasicRuleThresholds{
{
- Name: postableRule.AlertName,
+ Name: postableRule.AlertName.StringValue(),
TargetValue: &target,
MatchType: ruletypes.AtleastOnce,
CompareOperator: ruletypes.ValueIsEq,
@@ -808,7 +808,7 @@ func TestThresholdRuleNoData(t *testing.T) {
func TestThresholdRuleTracesLink(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "Traces link test",
+ AlertName: valuer.NewDisplayName("Traces link test"),
AlertType: ruletypes.AlertTypeTraces,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -876,7 +876,7 @@ func TestThresholdRuleTracesLink(t *testing.T) {
Kind: ruletypes.BasicThresholdKind,
Spec: ruletypes.BasicRuleThresholds{
{
- Name: postableRule.AlertName,
+ Name: postableRule.AlertName.StringValue(),
TargetValue: &c.target,
TargetUnit: c.targetUnit,
MatchType: c.matchType,
@@ -918,7 +918,7 @@ func TestThresholdRuleTracesLink(t *testing.T) {
func TestThresholdRuleAITracesLink(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "AI traces link test",
+ AlertName: valuer.NewDisplayName("AI traces link test"),
AlertType: ruletypes.AlertTypeAITraces,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -984,7 +984,7 @@ func TestThresholdRuleAITracesLink(t *testing.T) {
Kind: ruletypes.BasicThresholdKind,
Spec: ruletypes.BasicRuleThresholds{
{
- Name: postableRule.AlertName,
+ Name: postableRule.AlertName.StringValue(),
TargetValue: &c.target,
TargetUnit: c.targetUnit,
MatchType: c.matchType,
@@ -1016,7 +1016,7 @@ func TestThresholdRuleAITracesLink(t *testing.T) {
func TestThresholdRuleLogsLink(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "Logs link test",
+ AlertName: valuer.NewDisplayName("Logs link test"),
AlertType: ruletypes.AlertTypeLogs,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -1092,7 +1092,7 @@ func TestThresholdRuleLogsLink(t *testing.T) {
Kind: ruletypes.BasicThresholdKind,
Spec: ruletypes.BasicRuleThresholds{
{
- Name: postableRule.AlertName,
+ Name: postableRule.AlertName.StringValue(),
TargetValue: &c.target,
TargetUnit: c.targetUnit,
MatchType: c.matchType,
@@ -1134,7 +1134,7 @@ func TestThresholdRuleLogsLink(t *testing.T) {
func TestMultipleThresholdRule(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "Multiple threshold test",
+ AlertName: valuer.NewDisplayName("Multiple threshold test"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -1315,7 +1315,7 @@ func TestMultipleThresholdRule(t *testing.T) {
func TestThresholdRuleEval_BasicCases(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "Eval Recovery Threshold Test",
+ AlertName: valuer.NewDisplayName("Eval Recovery Threshold Test"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -1349,7 +1349,7 @@ func TestThresholdRuleEval_BasicCases(t *testing.T) {
func TestThresholdRuleEval_MatchPlusCompareOps(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "Eval Match Plus Compare Ops Threshold Test",
+ AlertName: valuer.NewDisplayName("Eval Match Plus Compare Ops Threshold Test"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -1389,7 +1389,7 @@ func TestThresholdRuleEval_SendUnmatchedBypassesRecovery(t *testing.T) {
recovery := 4.0
postableRule := ruletypes.PostableRule{
- AlertName: "Send unmatched bypass recovery",
+ AlertName: valuer.NewDisplayName("Send unmatched bypass recovery"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -1476,7 +1476,7 @@ func TestThresholdRuleEval_SendUnmatchedVariants(t *testing.T) {
target := 10.0
recovery := 5.0
postableRule := ruletypes.PostableRule{
- AlertName: "Send unmatched variants",
+ AlertName: valuer.NewDisplayName("Send unmatched variants"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -1588,7 +1588,7 @@ func TestThresholdRuleEval_RecoveryNotMetSendUnmatchedFalse(t *testing.T) {
now := time.Now()
postableRule := ruletypes.PostableRule{
- AlertName: "Recovery not met sendUnmatched false",
+ AlertName: valuer.NewDisplayName("Recovery not met sendUnmatched false"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -1888,7 +1888,7 @@ func runMultiThresholdEvalTests(t *testing.T, postableRule ruletypes.PostableRul
// where each threshold can be in a different state (firing, recovering, resolved)
func TestThresholdRuleEval_MultiThreshold(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "Multi-Threshold Recovery Test",
+ AlertName: valuer.NewDisplayName("Multi-Threshold Recovery Test"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -1922,7 +1922,7 @@ func TestThresholdRuleEval_MultiThreshold(t *testing.T) {
func TestThresholdEval_RequireMinPoints(t *testing.T) {
postableRule := ruletypes.PostableRule{
- AlertName: "Unit test",
+ AlertName: valuer.NewDisplayName("Unit test"),
AlertType: ruletypes.AlertTypeMetric,
RuleType: ruletypes.RuleTypeThreshold,
Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -2057,7 +2057,7 @@ func TestThresholdEval_RequireMinPoints(t *testing.T) {
Kind: ruletypes.BasicThresholdKind,
Spec: ruletypes.BasicRuleThresholds{
{
- Name: postableRule.AlertName,
+ Name: postableRule.AlertName.StringValue(),
TargetValue: &c.target,
MatchType: rc.MatchType,
CompareOperator: rc.CompareOperator,
diff --git a/pkg/ruler/handler.go b/pkg/ruler/handler.go
index 11a19b346e..79cda35885 100644
--- a/pkg/ruler/handler.go
+++ b/pkg/ruler/handler.go
@@ -7,6 +7,7 @@ type Handler interface {
ListRulesV3(http.ResponseWriter, *http.Request)
GetRuleByID(http.ResponseWriter, *http.Request)
CreateRule(http.ResponseWriter, *http.Request)
+ CloneRuleByID(http.ResponseWriter, *http.Request)
UpdateRuleByID(http.ResponseWriter, *http.Request)
DeleteRuleByID(http.ResponseWriter, *http.Request)
PatchRuleByID(http.ResponseWriter, *http.Request)
diff --git a/pkg/ruler/ruler.go b/pkg/ruler/ruler.go
index 9c75458411..f8d4d3cdaa 100644
--- a/pkg/ruler/ruler.go
+++ b/pkg/ruler/ruler.go
@@ -29,6 +29,9 @@ type Ruler interface {
// model to store structured data.
CreateRule(ctx context.Context, ruleStr string) (*ruletypes.GettableRule, error)
+ // CloneRule creates a new rule from the stored definition of id, with a " - Copy" suffixed name.
+ CloneRule(ctx context.Context, id valuer.UUID) (*ruletypes.GettableRule, error)
+
// EditRule replaces the rule identified by id with the given JSON string.
// TODO: same as CreateRule — accept PostableRule instead of raw string.
EditRule(ctx context.Context, ruleStr string, id valuer.UUID) error
diff --git a/pkg/ruler/rulestore/sqlrulestore/rule.go b/pkg/ruler/rulestore/sqlrulestore/rule.go
index c49c8f3b8c..9408161731 100644
--- a/pkg/ruler/rulestore/sqlrulestore/rule.go
+++ b/pkg/ruler/rulestore/sqlrulestore/rule.go
@@ -235,7 +235,7 @@ func (r *rule) GetStoredRulesByMetricName(ctx context.Context, orgID string, met
if found && !seen[storedRule.ID.StringValue()] {
seen[storedRule.ID.StringValue()] = true
alerts = append(alerts, ruletypes.RuleAlert{
- AlertName: ruleData.AlertName,
+ AlertName: ruleData.AlertName.StringValue(),
AlertID: storedRule.ID.StringValue(),
})
}
diff --git a/pkg/ruler/signozruler/handler.go b/pkg/ruler/signozruler/handler.go
index b8247c3e33..d4300a1c00 100644
--- a/pkg/ruler/signozruler/handler.go
+++ b/pkg/ruler/signozruler/handler.go
@@ -105,6 +105,25 @@ func (handler *handler) CreateRule(rw http.ResponseWriter, req *http.Request) {
render.Success(rw, http.StatusCreated, ruletypes.NewRule(rule))
}
+func (handler *handler) CloneRuleByID(rw http.ResponseWriter, req *http.Request) {
+ ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+ defer cancel()
+
+ id, err := valuer.NewUUID(mux.Vars(req)["id"])
+ if err != nil {
+ render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+ return
+ }
+
+ rule, err := handler.ruler.CloneRule(ctx, id)
+ if err != nil {
+ render.Error(rw, err)
+ return
+ }
+
+ render.Success(rw, http.StatusCreated, ruletypes.NewRule(rule))
+}
+
func (handler *handler) UpdateRuleByID(rw http.ResponseWriter, req *http.Request) {
ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
defer cancel()
diff --git a/pkg/ruler/signozruler/provider.go b/pkg/ruler/signozruler/provider.go
index 7dc806f8ee..8a16006e58 100644
--- a/pkg/ruler/signozruler/provider.go
+++ b/pkg/ruler/signozruler/provider.go
@@ -18,6 +18,7 @@ import (
"github.com/SigNoz/signoz/pkg/sqlstore"
"github.com/SigNoz/signoz/pkg/telemetrystore"
"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+ "github.com/SigNoz/signoz/pkg/types/authtypes"
"github.com/SigNoz/signoz/pkg/types/ruletypes"
"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
"github.com/SigNoz/signoz/pkg/valuer"
@@ -128,6 +129,30 @@ func (provider *provider) CreateRule(ctx context.Context, ruleStr string) (*rule
return provider.manager.CreateRule(ctx, ruleStr)
}
+func (provider *provider) CloneRule(ctx context.Context, id valuer.UUID) (*ruletypes.GettableRule, error) {
+ claims, err := authtypes.ClaimsFromContext(ctx)
+ if err != nil {
+ return nil, err
+ }
+
+ orgID, err := valuer.NewUUID(claims.OrgID)
+ if err != nil {
+ return nil, err
+ }
+
+ storedRule, err := provider.ruleStore.GetStoredRule(ctx, orgID, id)
+ if err != nil {
+ return nil, err
+ }
+
+ postableRule, err := storedRule.ToPostableRuleForCloning()
+ if err != nil {
+ return nil, err
+ }
+
+ return provider.manager.CreatePostableRule(ctx, postableRule)
+}
+
func (provider *provider) EditRule(ctx context.Context, ruleStr string, id valuer.UUID) error {
return provider.manager.EditRule(ctx, ruleStr, id)
}
diff --git a/pkg/types/ruletypes/api_params.go b/pkg/types/ruletypes/api_params.go
index a4da1816df..dc110db450 100644
--- a/pkg/types/ruletypes/api_params.go
+++ b/pkg/types/ruletypes/api_params.go
@@ -60,7 +60,7 @@ const (
// PostableRule is used to create alerting rule from HTTP api.
type PostableRule struct {
- AlertName string `json:"alert" required:"true"`
+ AlertName valuer.DisplayName `json:"alert" required:"true"`
AlertType AlertType `json:"alertType" required:"true"`
Description string `json:"description,omitempty"`
RuleType RuleType `json:"ruleType" required:"true"`
@@ -403,7 +403,7 @@ func (r *PostableRule) validate() error {
func (r *PostableRule) Validate() error {
var errs []error
- if r.AlertName == "" {
+ if r.AlertName.IsZero() {
errs = append(errs, errors.NewInvalidInputf(errors.CodeInvalidInput, "alert: field is required"))
}
@@ -585,7 +585,7 @@ func (r *PostableRule) validateV2Alpha1() []error {
}
func testTemplateParsing(rl *PostableRule) (errs []error) {
- if rl.AlertName == "" {
+ if rl.AlertName.IsZero() {
// Not an alerting rule.
return errs
}
@@ -597,7 +597,7 @@ func testTemplateParsing(rl *PostableRule) (errs []error) {
tmpl := NewTemplateExpander(
context.TODO(),
defs+text,
- "__alert_"+rl.AlertName,
+ "__alert_"+rl.AlertName.StringValue(),
tmplData,
nil,
)
diff --git a/pkg/types/ruletypes/api_params_test.go b/pkg/types/ruletypes/api_params_test.go
index bdb967b3cd..573f89b616 100644
--- a/pkg/types/ruletypes/api_params_test.go
+++ b/pkg/types/ruletypes/api_params_test.go
@@ -54,7 +54,7 @@ func TestParseIntoRule(t *testing.T) {
kind: RuleDataKindJson,
expectError: false,
validate: func(t *testing.T, rule *PostableRule) {
- if rule.AlertName != "TestAlert" {
+ if rule.AlertName.StringValue() != "TestAlert" {
t.Errorf("Expected alert name 'TestAlert', got '%s'", rule.AlertName)
}
if rule.RuleType != RuleTypeThreshold {
diff --git a/pkg/types/ruletypes/rule.go b/pkg/types/ruletypes/rule.go
index 3716520e3a..bb0be2a25a 100644
--- a/pkg/types/ruletypes/rule.go
+++ b/pkg/types/ruletypes/rule.go
@@ -48,6 +48,15 @@ func NewStatsFromRules(rules []*StorableRule) map[string]any {
return stats
}
+func (rule *StorableRule) ToPostableRuleForCloning() (*PostableRule, error) {
+ postable := &PostableRule{}
+ if err := json.Unmarshal([]byte(rule.Data), postable); err != nil {
+ return nil, err
+ }
+ postable.AlertName = postable.AlertName.GenerateCloneName()
+ return postable, nil
+}
+
// RuleAlert represents an alert associated with a rule, used when filtering by metric name.
type RuleAlert struct {
AlertName string
diff --git a/pkg/valuer/display_name.go b/pkg/valuer/display_name.go
new file mode 100644
index 0000000000..d4906bce07
--- /dev/null
+++ b/pkg/valuer/display_name.go
@@ -0,0 +1,110 @@
+package valuer
+
+import (
+ "database/sql/driver"
+ "encoding/json"
+ "fmt"
+ "reflect"
+ "regexp"
+ "strconv"
+
+ "github.com/SigNoz/signoz/pkg/errors"
+)
+
+var _ Valuer = (*DisplayName)(nil)
+
+var cloneCopySuffixRegex = regexp.MustCompile(`^(.*) - Copy(?: \((\d+)\))?$`)
+
+// DisplayName is a free-text, user-facing name; unlike String it is stored exactly as given.
+type DisplayName struct {
+ val string
+}
+
+func NewDisplayName(val string) DisplayName {
+ return DisplayName{val: val}
+}
+
+func (name DisplayName) IsZero() bool {
+ return name.val == ""
+}
+
+func (name DisplayName) StringValue() string {
+ return name.val
+}
+
+func (name DisplayName) String() string {
+ return name.val
+}
+
+// GenerateCloneName appends " - Copy" or bumps an existing " - Copy (n)" counter.
+func (name DisplayName) GenerateCloneName() DisplayName {
+ base, count := name.val, 0
+ if m := cloneCopySuffixRegex.FindStringSubmatch(name.val); m != nil {
+ base = m[1]
+ count = 1 // bare " - Copy"
+ if m[2] != "" {
+ count, _ = strconv.Atoi(m[2])
+ }
+ }
+
+ if count++; count > 1 {
+ return NewDisplayName(fmt.Sprintf("%s - Copy (%d)", base, count))
+ }
+ return NewDisplayName(fmt.Sprintf("%s - Copy", base))
+}
+
+func (name DisplayName) MarshalJSON() ([]byte, error) {
+ return json.Marshal(name.val)
+}
+
+// UnmarshalJSON treats null as a no-op, matching how a plain string field decodes.
+func (name *DisplayName) UnmarshalJSON(data []byte) error {
+ if string(data) == "null" {
+ return nil
+ }
+
+ var str string
+ if err := json.Unmarshal(data, &str); err != nil {
+ return err
+ }
+
+ *name = NewDisplayName(str)
+ return nil
+}
+
+func (name DisplayName) Value() (driver.Value, error) {
+ return name.val, nil
+}
+
+func (name *DisplayName) Scan(val any) error {
+ if name == nil {
+ return errors.Newf(errors.TypeInternal, ErrCodeUnknownValuerScan, "display name: (nil \"%s\")", reflect.TypeOf(name).String())
+ }
+
+ if val == nil {
+ *name = NewDisplayName("")
+ return nil
+ }
+
+ str, ok := val.(string)
+ if !ok {
+ return errors.Newf(errors.TypeInternal, ErrCodeUnknownValuerScan, "display name: (non-string \"%s\")", reflect.TypeOf(val).String())
+ }
+
+ *name = NewDisplayName(str)
+ return nil
+}
+
+func (name *DisplayName) UnmarshalText(text []byte) error {
+ *name = NewDisplayName(string(text))
+ return nil
+}
+
+func (name DisplayName) MarshalText() ([]byte, error) {
+ return []byte(name.val), nil
+}
+
+func (name *DisplayName) UnmarshalParam(param string) error {
+ *name = NewDisplayName(param)
+ return nil
+}
diff --git a/pkg/valuer/display_name_test.go b/pkg/valuer/display_name_test.go
new file mode 100644
index 0000000000..331ce707c8
--- /dev/null
+++ b/pkg/valuer/display_name_test.go
@@ -0,0 +1,112 @@
+package valuer
+
+import (
+ "encoding/json"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+func TestDisplayName_GenerateCloneName(t *testing.T) {
+ testCases := []struct {
+ name string
+ input string
+ expected string
+ }{
+ {name: "PlainName_CopySuffixAppended", input: "High CPU", expected: "High CPU - Copy"},
+ {name: "CopySuffix_BumpedToTwo", input: "High CPU - Copy", expected: "High CPU - Copy (2)"},
+ {name: "NumberedSuffix_Incremented", input: "High CPU - Copy (2)", expected: "High CPU - Copy (3)"},
+ {name: "MultiDigitSuffix_Incremented", input: "svc - Copy (41)", expected: "svc - Copy (42)"},
+ {name: "ContainsCopyWord_NotTreatedAsSuffix", input: "Copy of things", expected: "Copy of things - Copy"},
+ {name: "RepeatedCopy_OnlyTrailingMarkerParsed", input: "Prod - Copy - Copy", expected: "Prod - Copy - Copy (2)"},
+ {name: "EmptyName_SuffixOnly", input: "", expected: " - Copy"},
+ {
+ name: "LongName_NotTruncated",
+ input: "Muting And Manual Resolving Log Based Alert 7 October With A Very Long Descriptive Name That Goes On And On Past One Hundred Twenty Eight Characters",
+ expected: "Muting And Manual Resolving Log Based Alert 7 October With A Very Long Descriptive Name That Goes On And On Past One Hundred Twenty Eight Characters - Copy",
+ },
+ }
+
+ for _, testCase := range testCases {
+ t.Run(testCase.name, func(t *testing.T) {
+ assert.Equal(t, testCase.expected, NewDisplayName(testCase.input).GenerateCloneName().StringValue())
+ })
+ }
+}
+
+func TestDisplayName_UnmarshalJSON(t *testing.T) {
+ testCases := []struct {
+ name string
+ existing string
+ input string
+ expected string
+ expectErr bool
+ }{
+ {name: "MixedCaseAndWhitespace_Preserved", input: `" High CPU Mixed "`, expected: " High CPU Mixed "},
+ {name: "Null_KeepsExistingValue", existing: "kept", input: `null`, expected: "kept"},
+ {name: "NonString_Error", input: `42`, expectErr: true},
+ }
+
+ for _, testCase := range testCases {
+ t.Run(testCase.name, func(t *testing.T) {
+ name := NewDisplayName(testCase.existing)
+
+ err := json.Unmarshal([]byte(testCase.input), &name)
+ if testCase.expectErr {
+ require.Error(t, err)
+ return
+ }
+ require.NoError(t, err)
+ assert.Equal(t, testCase.expected, name.StringValue())
+ })
+ }
+}
+
+func TestDisplayName_MarshalJSON(t *testing.T) {
+ out, err := json.Marshal(struct {
+ Name DisplayName `json:"name"`
+ }{Name: NewDisplayName(" High CPU ")})
+ require.NoError(t, err)
+ assert.JSONEq(t, `{"name": " High CPU "}`, string(out))
+}
+
+func TestDisplayName_Scan(t *testing.T) {
+ testCases := []struct {
+ name string
+ input any
+ expected string
+ expectErr bool
+ }{
+ {name: "String_Scanned", input: "High CPU", expected: "High CPU"},
+ {name: "Nil_ScannedAsZero", input: nil, expected: ""},
+ {name: "NonString_Error", input: 42, expectErr: true},
+ }
+
+ for _, testCase := range testCases {
+ t.Run(testCase.name, func(t *testing.T) {
+ name := NewDisplayName("previous")
+
+ err := name.Scan(testCase.input)
+ if testCase.expectErr {
+ require.Error(t, err)
+ return
+ }
+ require.NoError(t, err)
+ assert.Equal(t, testCase.expected, name.StringValue())
+
+ value, err := name.Value()
+ require.NoError(t, err)
+ assert.Equal(t, testCase.expected, value)
+ })
+ }
+}
+
+func TestDisplayName_TextRoundTrip(t *testing.T) {
+ text, err := NewDisplayName(" High CPU ").MarshalText()
+ require.NoError(t, err)
+
+ var name DisplayName
+ require.NoError(t, name.UnmarshalText(text))
+ assert.Equal(t, " High CPU ", name.StringValue())
+}
diff --git a/tests/integration/tests/ruler/07_clone_rule.py b/tests/integration/tests/ruler/07_clone_rule.py
new file mode 100644
index 0000000000..2c7e79848e
--- /dev/null
+++ b/tests/integration/tests/ruler/07_clone_rule.py
@@ -0,0 +1,150 @@
+import uuid
+from collections.abc import Callable
+from http import HTTPStatus
+
+import requests
+
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
+from fixtures.types import Operation, SigNoz
+
+BASE_URL = "/api/v2/rules"
+
+CHANNELS_URL = "/api/v2/notification_channels"
+
+CHANNEL_NAME = f"clone-rule-channel-{uuid.uuid4()}"
+
+SOURCE_RULE = {
+ "alert": "clone me",
+ "description": "source rule for clone",
+ "alertType": "METRIC_BASED_ALERT",
+ "ruleType": "threshold_rule",
+ "condition": {
+ "thresholds": {
+ "kind": "basic",
+ "spec": [{"name": "critical", "target": 90, "matchType": "at_least_once", "op": "above", "channels": [CHANNEL_NAME]}],
+ },
+ "compositeQuery": {
+ "queryType": "builder",
+ "panelType": "graph",
+ "queries": [
+ {
+ "type": "builder_query",
+ "spec": {
+ "name": "A",
+ "signal": "metrics",
+ "aggregations": [{"metricName": "clone_rule_cpu", "timeAggregation": "avg", "spaceAggregation": "max"}],
+ },
+ }
+ ],
+ },
+ "selectedQueryName": "A",
+ },
+ "labels": {"severity": "critical", "team": "payments"},
+ "annotations": {"summary": "s", "description": "d"},
+ "disabled": True,
+ "evaluation": {"kind": "rolling", "spec": {"evalWindow": "5m0s", "frequency": "1m"}},
+ "notificationSettings": {
+ "groupBy": [],
+ "usePolicy": False,
+ "renotify": {"enabled": False, "interval": "30m", "alertStates": []},
+ },
+ "version": "v5",
+ "schemaVersion": "v2alpha1",
+}
+
+
+def test_clone_rule(
+ signoz: SigNoz,
+ create_user_admin: Operation, # pylint: disable=unused-argument
+ get_token: Callable[[str, str], str],
+):
+ token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+ response = requests.post(
+ signoz.self.host_configs["8080"].get(CHANNELS_URL),
+ json={"name": CHANNEL_NAME, "config": {"kind": "webhook", "spec": {"url": "https://webhook.test/hook"}}},
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert response.status_code == HTTPStatus.CREATED, response.text
+ channel_id = response.json()["data"]["id"]
+
+ response = requests.post(
+ signoz.self.host_configs["8080"].get(BASE_URL),
+ json=SOURCE_RULE,
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert response.status_code == HTTPStatus.CREATED, response.text
+ source_id = response.json()["data"]["id"]
+
+ response = requests.get(
+ signoz.self.host_configs["8080"].get(f"{BASE_URL}/{source_id}"),
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert response.status_code == HTTPStatus.OK, response.text
+ source = response.json()["data"]
+
+ # clone keeps everything but the id and name
+ response = requests.post(
+ signoz.self.host_configs["8080"].get(f"{BASE_URL}/{source_id}/clone"),
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert response.status_code == HTTPStatus.CREATED, response.text
+ clone = response.json()["data"]
+ assert clone["id"] != source_id
+ assert clone["alert"] == "clone me - Copy"
+ for field in ["description", "alertType", "ruleType", "disabled", "labels", "annotations", "condition", "evaluation", "notificationSettings"]:
+ assert clone[field] == source[field], field
+
+ response = requests.get(
+ signoz.self.host_configs["8080"].get(f"{BASE_URL}/{clone['id']}"),
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert response.status_code == HTTPStatus.OK, response.text
+ assert response.json()["data"]["alert"] == "clone me - Copy"
+ assert response.json()["data"]["state"] == "disabled"
+ assert response.json()["data"]["createdBy"] == USER_ADMIN_EMAIL
+
+ # cloning a copy bumps the counter
+ response = requests.post(
+ signoz.self.host_configs["8080"].get(f"{BASE_URL}/{clone['id']}/clone"),
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert response.status_code == HTTPStatus.CREATED, response.text
+ second_clone = response.json()["data"]
+ assert second_clone["alert"] == "clone me - Copy (2)"
+ assert second_clone["condition"] == source["condition"]
+
+ response = requests.post(
+ signoz.self.host_configs["8080"].get(f"{BASE_URL}/{uuid.uuid4()}/clone"),
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert response.status_code == HTTPStatus.NOT_FOUND, response.text
+
+ response = requests.post(
+ signoz.self.host_configs["8080"].get(f"{BASE_URL}/not-a-uuid/clone"),
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+
+ for rule_id in [source_id, clone["id"], second_clone["id"]]:
+ response = requests.delete(
+ signoz.self.host_configs["8080"].get(f"{BASE_URL}/{rule_id}"),
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert response.status_code == HTTPStatus.NO_CONTENT, response.text
+
+ response = requests.delete(
+ signoz.self.host_configs["8080"].get(f"{CHANNELS_URL}/{channel_id}"),
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert response.status_code == HTTPStatus.NO_CONTENT, response.text