chore: base path setup and routing and navigation migrations

cmd/community/server.go

@@ -7,7 +7,6 @@ import (
 	"github.com/spf13/cobra"
 
 	"github.com/SigNoz/signoz/cmd"
-	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/analytics"
 	"github.com/SigNoz/signoz/pkg/auditor"
 	"github.com/SigNoz/signoz/pkg/authn"
@@ -15,7 +14,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/authz/openfgaauthz"
 	"github.com/SigNoz/signoz/pkg/authz/openfgaschema"
 	"github.com/SigNoz/signoz/pkg/authz/openfgaserver"
-	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/gateway"
@@ -28,20 +26,14 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
-	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/query-service/app"
 	"github.com/SigNoz/signoz/pkg/queryparser"
-	"github.com/SigNoz/signoz/pkg/ruler"
-	"github.com/SigNoz/signoz/pkg/ruler/signozruler"
 	"github.com/SigNoz/signoz/pkg/signoz"
 	"github.com/SigNoz/signoz/pkg/sqlschema"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/SigNoz/signoz/pkg/zeus"
 	"github.com/SigNoz/signoz/pkg/zeus/noopzeus"
@@ -115,9 +107,6 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 		func(_ sqlstore.SQLStore, _ global.Global, _ zeus.Zeus, _ gateway.Gateway, _ licensing.Licensing, _ serviceaccount.Module, _ cloudintegration.Config) (cloudintegration.Module, error) {
 			return implcloudintegration.NewModule(), nil
 		},
-		func(c cache.Cache, am alertmanager.Alertmanager, ss sqlstore.SQLStore, ts telemetrystore.TelemetryStore, ms telemetrytypes.MetadataStore, p prometheus.Prometheus, og organization.Getter, rsh rulestatehistory.Module, q querier.Querier, qp queryparser.QueryParser) factory.NamedMap[factory.ProviderFactory[ruler.Ruler, ruler.Config]] {
-			return factory.MustNewNamedMap(signozruler.NewFactory(c, am, ss, ts, ms, p, og, rsh, q, qp, nil, nil))
-		},
 	)
 	if err != nil {
 		logger.ErrorContext(ctx, "failed to create signoz", errors.Attr(err))

cmd/enterprise/server.go

@@ -22,17 +22,14 @@ import (
 	"github.com/SigNoz/signoz/ee/modules/dashboard/impldashboard"
 	eequerier "github.com/SigNoz/signoz/ee/querier"
 	enterpriseapp "github.com/SigNoz/signoz/ee/query-service/app"
-	eerules "github.com/SigNoz/signoz/ee/query-service/rules"
 	"github.com/SigNoz/signoz/ee/sqlschema/postgressqlschema"
 	"github.com/SigNoz/signoz/ee/sqlstore/postgressqlstore"
 	enterprisezeus "github.com/SigNoz/signoz/ee/zeus"
 	"github.com/SigNoz/signoz/ee/zeus/httpzeus"
-	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/analytics"
 	"github.com/SigNoz/signoz/pkg/auditor"
 	"github.com/SigNoz/signoz/pkg/authn"
 	"github.com/SigNoz/signoz/pkg/authz"
-	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/gateway"
@@ -43,21 +40,15 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	pkgimpldashboard "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
-	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/queryparser"
-	"github.com/SigNoz/signoz/pkg/ruler"
-	"github.com/SigNoz/signoz/pkg/ruler/signozruler"
 	"github.com/SigNoz/signoz/pkg/signoz"
 	"github.com/SigNoz/signoz/pkg/sqlschema"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/sqlstore/sqlstorehook"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/types/cloudintegrationtypes"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/SigNoz/signoz/pkg/zeus"
 )
@@ -175,9 +166,6 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 
 			return implcloudintegration.NewModule(pkgcloudintegration.NewStore(sqlStore), global, zeus, gateway, licensing, serviceAccount, cloudProvidersMap, config)
 		},
-		func(c cache.Cache, am alertmanager.Alertmanager, ss sqlstore.SQLStore, ts telemetrystore.TelemetryStore, ms telemetrytypes.MetadataStore, p prometheus.Prometheus, og organization.Getter, rsh rulestatehistory.Module, q querier.Querier, qp queryparser.QueryParser) factory.NamedMap[factory.ProviderFactory[ruler.Ruler, ruler.Config]] {
-			return factory.MustNewNamedMap(signozruler.NewFactory(c, am, ss, ts, ms, p, og, rsh, q, qp, eerules.PrepareTaskFunc, eerules.TestNotification))
-		},
 	)
 	if err != nil {
 		logger.ErrorContext(ctx, "failed to create signoz", errors.Attr(err))

deploy/docker-swarm/docker-compose.ha.yaml

@@ -190,7 +190,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.119.0
+    image: signoz/signoz:v0.118.0
     ports:
       - "8080:8080" # signoz port
     #   - "6060:6060"     # pprof port

deploy/docker-swarm/docker-compose.yaml

@@ -117,7 +117,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.119.0
+    image: signoz/signoz:v0.118.0
     ports:
       - "8080:8080" # signoz port
     volumes:

deploy/docker/docker-compose.ha.yaml

@@ -181,7 +181,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.119.0}
+    image: signoz/signoz:${VERSION:-v0.118.0}
     container_name: signoz
     ports:
       - "8080:8080" # signoz port

deploy/docker/docker-compose.yaml

@@ -109,7 +109,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.119.0}
+    image: signoz/signoz:${VERSION:-v0.118.0}
     container_name: signoz
     ports:
       - "8080:8080" # signoz port

docs/contributing/onboarding.md

@@ -7,12 +7,12 @@ This guide explains how to add new data sources to the SigNoz onboarding flow. T
 The configuration is located at:
 
 ```
-frontend/src/container/OnboardingV2Container/onboarding-configs/onboarding-config-with-links.ts
+frontend/src/container/OnboardingV2Container/onboarding-configs/onboarding-config-with-links.json
 ```
 
-## Structure Overview
+## JSON Structure Overview
 
-The configuration file exports a TypeScript array (`onboardingConfigWithLinks`) containing data source objects. Each object represents a selectable option in the onboarding flow. SVG logos are imported as ES modules at the top of the file.
+The configuration file is a JSON array containing data source objects. Each object represents a selectable option in the onboarding flow.
 
 ## Data Source Object Keys
 
@@ -24,7 +24,7 @@ The configuration file exports a TypeScript array (`onboardingConfigWithLinks`)
 | `label` | `string` | Display name shown to users (e.g., `"AWS EC2"`) |
 | `tags` | `string[]` | Array of category tags for grouping (e.g., `["AWS"]`, `["database"]`) |
 | `module` | `string` | Destination module after onboarding completion |
-| `imgUrl` | `string` | Imported SVG URL **(SVG required)** (e.g., `import ec2Url from '@/assets/Logos/ec2.svg'`, then use `ec2Url`) |
+| `imgUrl` | `string` | Path to the logo/icon **(SVG required)** (e.g., `"/Logos/ec2.svg"`) |
 
 ### Optional Keys
 
@@ -57,34 +57,36 @@ The `module` key determines where users are redirected after completing onboardi
 
 The `question` object enables multi-step selection flows:
 
-```ts
-question: {
-  desc: 'What would you like to monitor?',
-  type: 'select',
-  helpText: 'Choose the telemetry type you want to collect.',
-  helpLink: '/docs/azure-monitoring/overview/',
-  helpLinkText: 'Read the guide →',
-  options: [
-    {
-      key: 'logging',
-      label: 'Logs',
-      imgUrl: azureVmUrl,
-      link: '/docs/azure-monitoring/app-service/logging/',
-    },
-    {
-      key: 'metrics',
-      label: 'Metrics',
-      imgUrl: azureVmUrl,
-      link: '/docs/azure-monitoring/app-service/metrics/',
-    },
-    {
-      key: 'tracing',
-      label: 'Traces',
-      imgUrl: azureVmUrl,
-      link: '/docs/azure-monitoring/app-service/tracing/',
-    },
-  ],
-},
+```json
+{
+  "question": {
+    "desc": "What would you like to monitor?",
+    "type": "select",
+    "helpText": "Choose the telemetry type you want to collect.",
+    "helpLink": "/docs/azure-monitoring/overview/",
+    "helpLinkText": "Read the guide →",
+    "options": [
+        {
+            "key": "logging",
+            "label": "Logs",
+            "imgUrl": "/Logos/azure-vm.svg",
+            "link": "/docs/azure-monitoring/app-service/logging/"
+        },
+        {
+            "key": "metrics",
+            "label": "Metrics",
+            "imgUrl": "/Logos/azure-vm.svg",
+            "link": "/docs/azure-monitoring/app-service/metrics/"
+        },
+        {
+            "key": "tracing",
+            "label": "Traces",
+            "imgUrl": "/Logos/azure-vm.svg",
+            "link": "/docs/azure-monitoring/app-service/tracing/"
+        }
+    ]
+  }
+}
 ```
 
 ### Question Keys
@@ -104,161 +106,152 @@ Options can be simple (direct link) or nested (with another question):
 
 ### Simple Option (Direct Link)
 
-```ts
+```json
 {
-  key: 'aws-ec2-logs',
-  label: 'Logs',
-  imgUrl: ec2Url,
-  link: '/docs/userguide/collect_logs_from_file/',
-},
+  "key": "aws-ec2-logs",
+  "label": "Logs",
+  "imgUrl": "/Logos/ec2.svg",
+  "link": "/docs/userguide/collect_logs_from_file/"
+}
 ```
 
 ### Option with Internal Redirect
 
-```ts
+```json
 {
-  key: 'aws-ec2-metrics-one-click',
-  label: 'One Click AWS',
-  imgUrl: ec2Url,
-  link: '/integrations?integration=aws-integration&service=ec2',
-  internalRedirect: true,
-},
+  "key": "aws-ec2-metrics-one-click",
+  "label": "One Click AWS",
+  "imgUrl": "/Logos/ec2.svg",
+  "link": "/integrations?integration=aws-integration&service=ec2",
+  "internalRedirect": true
+}
 ```
 
 > **Important**: Set `internalRedirect: true` only for internal app routes (like `/integrations?...`). Docs links should NOT have this flag.
 
 ### Nested Option (Multi-step Flow)
 
-```ts
+```json
 {
-  key: 'aws-ec2-metrics',
-  label: 'Metrics',
-  imgUrl: ec2Url,
-  question: {
-    desc: 'How would you like to set up monitoring?',
-    helpText: 'Choose your setup method.',
-    options: [...],
-  },
-},
+  "key": "aws-ec2-metrics",
+  "label": "Metrics",
+  "imgUrl": "/Logos/ec2.svg",
+  "question": {
+    "desc": "How would you like to set up monitoring?",
+    "helpText": "Choose your setup method.",
+    "options": [...]
+  }
+}
 ```
 
 ## Examples
 
 ### Simple Data Source (Direct Link)
 
-```ts
-import elbUrl from '@/assets/Logos/elb.svg';
-
-// inside the onboardingConfigWithLinks array:
+```json
 {
-  dataSource: 'aws-elb',
-  label: 'AWS ELB',
-  tags: ['AWS'],
-  module: 'logs',
-  relatedSearchKeywords: [
-    'aws',
-    'aws elb',
-    'elb logs',
-    'elastic load balancer',
+  "dataSource": "aws-elb",
+  "label": "AWS ELB",
+  "tags": ["AWS"],
+  "module": "logs",
+  "relatedSearchKeywords": [
+    "aws",
+    "aws elb",
+    "elb logs",
+    "elastic load balancer"
   ],
-  imgUrl: elbUrl,
-  link: '/docs/aws-monitoring/elb/',
-},
+  "imgUrl": "/Logos/elb.svg",
+  "link": "/docs/aws-monitoring/elb/"
+}
 ```
 
 ### Data Source with Single Question Level
 
-```ts
-import azureVmUrl from '@/assets/Logos/azure-vm.svg';
-
-// inside the onboardingConfigWithLinks array:
+```json
 {
-  dataSource: 'app-service',
-  label: 'App Service',
-  imgUrl: azureVmUrl,
-  tags: ['Azure'],
-  module: 'apm',
-  relatedSearchKeywords: ['azure', 'app service'],
-  question: {
-    desc: 'What telemetry data do you want to visualise?',
-    type: 'select',
-    options: [
+  "dataSource": "app-service",
+  "label": "App Service",
+  "imgUrl": "/Logos/azure-vm.svg",
+  "tags": ["Azure"],
+  "module": "apm",
+  "relatedSearchKeywords": ["azure", "app service"],
+  "question": {
+    "desc": "What telemetry data do you want to visualise?",
+    "type": "select",
+    "options": [
       {
-        key: 'logging',
-        label: 'Logs',
-        imgUrl: azureVmUrl,
-        link: '/docs/azure-monitoring/app-service/logging/',
+        "key": "logging",
+        "label": "Logs",
+        "imgUrl": "/Logos/azure-vm.svg",
+        "link": "/docs/azure-monitoring/app-service/logging/"
       },
       {
-        key: 'metrics',
-        label: 'Metrics',
-        imgUrl: azureVmUrl,
-        link: '/docs/azure-monitoring/app-service/metrics/',
+        "key": "metrics",
+        "label": "Metrics",
+        "imgUrl": "/Logos/azure-vm.svg",
+        "link": "/docs/azure-monitoring/app-service/metrics/"
       },
       {
-        key: 'tracing',
-        label: 'Traces',
-        imgUrl: azureVmUrl,
-        link: '/docs/azure-monitoring/app-service/tracing/',
-      },
-    ],
-  },
-},
+        "key": "tracing",
+        "label": "Traces",
+        "imgUrl": "/Logos/azure-vm.svg",
+        "link": "/docs/azure-monitoring/app-service/tracing/"
+      }
+    ]
+  }
+}
 ```
 
 ### Data Source with Nested Questions (2-3 Levels)
 
-```ts
-import ec2Url from '@/assets/Logos/ec2.svg';
-
-// inside the onboardingConfigWithLinks array:
+```json
 {
-  dataSource: 'aws-ec2',
-  label: 'AWS EC2',
-  tags: ['AWS'],
-  module: 'logs',
-  relatedSearchKeywords: ['aws', 'aws ec2', 'ec2 logs', 'ec2 metrics'],
-  imgUrl: ec2Url,
-  question: {
-    desc: 'What would you like to monitor for AWS EC2?',
-    type: 'select',
-    helpText: 'Choose the type of telemetry data you want to collect.',
-    options: [
+  "dataSource": "aws-ec2",
+  "label": "AWS EC2",
+  "tags": ["AWS"],
+  "module": "logs",
+  "relatedSearchKeywords": ["aws", "aws ec2", "ec2 logs", "ec2 metrics"],
+  "imgUrl": "/Logos/ec2.svg",
+  "question": {
+    "desc": "What would you like to monitor for AWS EC2?",
+    "type": "select",
+    "helpText": "Choose the type of telemetry data you want to collect.",
+    "options": [
       {
-        key: 'aws-ec2-logs',
-        label: 'Logs',
-        imgUrl: ec2Url,
-        link: '/docs/userguide/collect_logs_from_file/',
+        "key": "aws-ec2-logs",
+        "label": "Logs",
+        "imgUrl": "/Logos/ec2.svg",
+        "link": "/docs/userguide/collect_logs_from_file/"
       },
       {
-        key: 'aws-ec2-metrics',
-        label: 'Metrics',
-        imgUrl: ec2Url,
-        question: {
-          desc: 'How would you like to set up EC2 Metrics monitoring?',
-          helpText: 'One Click uses AWS CloudWatch integration. Manual setup uses OpenTelemetry.',
-          helpLink: '/docs/aws-monitoring/one-click-vs-manual/',
-          helpLinkText: 'Read the comparison guide →',
-          options: [
+        "key": "aws-ec2-metrics",
+        "label": "Metrics",
+        "imgUrl": "/Logos/ec2.svg",
+        "question": {
+          "desc": "How would you like to set up EC2 Metrics monitoring?",
+          "helpText": "One Click uses AWS CloudWatch integration. Manual setup uses OpenTelemetry.",
+          "helpLink": "/docs/aws-monitoring/one-click-vs-manual/",
+          "helpLinkText": "Read the comparison guide →",
+          "options": [
             {
-              key: 'aws-ec2-metrics-one-click',
-              label: 'One Click AWS',
-              imgUrl: ec2Url,
-              link: '/integrations?integration=aws-integration&service=ec2',
-              internalRedirect: true,
+              "key": "aws-ec2-metrics-one-click",
+              "label": "One Click AWS",
+              "imgUrl": "/Logos/ec2.svg",
+              "link": "/integrations?integration=aws-integration&service=ec2",
+              "internalRedirect": true
             },
             {
-              key: 'aws-ec2-metrics-manual',
-              label: 'Manual Setup',
-              imgUrl: ec2Url,
-              link: '/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/',
-            },
-          ],
-        },
-      },
-    ],
-  },
-},
+              "key": "aws-ec2-metrics-manual",
+              "label": "Manual Setup",
+              "imgUrl": "/Logos/ec2.svg",
+              "link": "/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/"
+            }
+          ]
+        }
+      }
+    ]
+  }
+}
 ```
 
 ## Best Practices
@@ -277,16 +270,11 @@ import ec2Url from '@/assets/Logos/ec2.svg';
 
 ### 3. Logos
 
-- Place logo files in `src/assets/Logos/`
+- Place logo files in `public/Logos/`
 - Use SVG format
-- Import the SVG at the top of the file and reference the imported variable:
-  ```ts
-  import myServiceUrl from '@/assets/Logos/my-service.svg';
-  // then in the config object:
-  imgUrl: myServiceUrl,
-  ```
+- Reference as `"/Logos/your-logo.svg"`
 - **Fetching Icons**: New icons can be easily fetched from [OpenBrand](https://openbrand.sh/). Use the pattern `https://openbrand.sh/?url=<TARGET_URL>`, where `<TARGET_URL>` is the URL-encoded link to the service's website. For example, to get Render's logo, use [https://openbrand.sh/?url=https%3A%2F%2Frender.com](https://openbrand.sh/?url=https%3A%2F%2Frender.com).
-- **Optimize new SVGs**: Run any newly downloaded SVGs through an optimizer like [SVGOMG (svgo)](https://svgomg.net/) or use `npx svgo src/assets/Logos/your-logo.svg` to minimise their size before committing.
+- **Optimize new SVGs**: Run any newly downloaded SVGs through an optimizer like [SVGOMG (svgo)](https://svgomg.net/) or use `npx svgo public/Logos/your-logo.svg` to minimise their size before committing.
 
 ### 4. Links
 
@@ -302,8 +290,8 @@ import ec2Url from '@/assets/Logos/ec2.svg';
 
 ## Adding a New Data Source
 
-1. Add the logo SVG to `src/assets/Logos/` and add a top-level import in the config file (e.g., `import myServiceUrl from '@/assets/Logos/my-service.svg'`)
-2. Add your data source object to the `onboardingConfigWithLinks` array, referencing the imported variable for `imgUrl`
+1. Add your data source object to the JSON array
+2. Ensure the logo exists in `public/Logos/`
 3. Test the flow locally with `yarn dev`
 4. Validation:
    - Navigate to the [onboarding page](http://localhost:3301/get-started-with-signoz-cloud) on your local machine

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

@@ -6,6 +6,7 @@ import (
 
 	"github.com/SigNoz/signoz/ee/licensing/httplicensing"
 	"github.com/SigNoz/signoz/ee/query-service/usage"
+	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	baseapp "github.com/SigNoz/signoz/pkg/query-service/app"
@@ -14,6 +15,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/app/logparsingpipeline"
 	"github.com/SigNoz/signoz/pkg/query-service/interfaces"
 	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
+	rules "github.com/SigNoz/signoz/pkg/query-service/rules"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/signoz"
 	"github.com/SigNoz/signoz/pkg/version"
@@ -22,6 +24,7 @@ import (
 
 type APIHandlerOptions struct {
 	DataConnector                 interfaces.Reader
+	RulesManager                  *rules.Manager
 	UsageManager                  *usage.Manager
 	IntegrationsController        *integrations.Controller
 	CloudIntegrationsController   *cloudintegrations.Controller
@@ -41,10 +44,12 @@ type APIHandler struct {
 func NewAPIHandler(opts APIHandlerOptions, signoz *signoz.SigNoz, config signoz.Config) (*APIHandler, error) {
 	baseHandler, err := baseapp.NewAPIHandler(baseapp.APIHandlerOpts{
 		Reader:                        opts.DataConnector,
+		RuleManager:                   opts.RulesManager,
 		IntegrationsController:        opts.IntegrationsController,
 		CloudIntegrationsController:   opts.CloudIntegrationsController,
 		LogsParsingPipelineController: opts.LogsParsingPipelineController,
 		FluxInterval:                  opts.FluxInterval,
+		AlertmanagerAPI:               alertmanager.NewAPI(signoz.Alertmanager),
 		LicensingAPI:                  httplicensing.NewLicensingAPI(signoz.Licensing),
 		Signoz:                        signoz,
 		QueryParserAPI:                queryparser.NewAPI(signoz.Instrumentation.ToProviderSettings(), signoz.QueryParser),
@@ -61,6 +66,10 @@ func NewAPIHandler(opts APIHandlerOptions, signoz *signoz.SigNoz, config signoz.
 	return ah, nil
 }
 
+func (ah *APIHandler) RM() *rules.Manager {
+	return ah.opts.RulesManager
+}
+
 func (ah *APIHandler) UM() *usage.Manager {
 	return ah.opts.UsageManager
 }

ee/query-service/app/server.go

@@ -12,6 +12,10 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/cache/memorycache"
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/queryparser"
+	"github.com/SigNoz/signoz/pkg/ruler/rulestore/sqlrulestore"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 
 	"github.com/gorilla/handlers"
 
@@ -19,10 +23,18 @@ import (
 	"github.com/soheilhy/cmux"
 
 	"github.com/SigNoz/signoz/ee/query-service/app/api"
+	"github.com/SigNoz/signoz/ee/query-service/rules"
 	"github.com/SigNoz/signoz/ee/query-service/usage"
+	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
+	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
+	"github.com/SigNoz/signoz/pkg/prometheus"
+	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/signoz"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/web"
 
 	"log/slog"
@@ -37,6 +49,7 @@ import (
 	opAmpModel "github.com/SigNoz/signoz/pkg/query-service/app/opamp/model"
 	baseconst "github.com/SigNoz/signoz/pkg/query-service/constants"
 	"github.com/SigNoz/signoz/pkg/query-service/healthcheck"
+	baserules "github.com/SigNoz/signoz/pkg/query-service/rules"
 	"github.com/SigNoz/signoz/pkg/query-service/utils"
 )
 
@@ -44,6 +57,7 @@ import (
 type Server struct {
 	config      signoz.Config
 	signoz      *signoz.SigNoz
+	ruleManager *baserules.Manager
 
 	// public http router
 	httpConn     net.Listener
@@ -83,6 +97,24 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 		nil,
 	)
 
+	rm, err := makeRulesManager(
+		signoz.Cache,
+		signoz.Alertmanager,
+		signoz.SQLStore,
+		signoz.TelemetryStore,
+		signoz.TelemetryMetadataStore,
+		signoz.Prometheus,
+		signoz.Modules.OrgGetter,
+		signoz.Modules.RuleStateHistory,
+		signoz.Querier,
+		signoz.Instrumentation.ToProviderSettings(),
+		signoz.QueryParser,
+	)
+
+	if err != nil {
+		return nil, err
+	}
+
 	// initiate opamp
 	opAmpModel.Init(signoz.SQLStore, signoz.Instrumentation.Logger(), signoz.Modules.OrgGetter)
 
@@ -131,6 +163,7 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 
 	apiOpts := api.APIHandlerOptions{
 		DataConnector:                 reader,
+		RulesManager:                  rm,
 		UsageManager:                  usageManager,
 		IntegrationsController:        integrationsController,
 		CloudIntegrationsController:   cloudIntegrationsController,
@@ -147,7 +180,8 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 
 	s := &Server{
 		config:             config,
-		signoz:       signoz,
+		signoz:             signoz,
+		ruleManager:        rm,
 		httpHostPort:       baseconst.HTTPHostPort,
 		unavailableChannel: make(chan healthcheck.Status),
 		usageManager:       usageManager,
@@ -254,6 +288,8 @@ func (s *Server) initListeners() error {
 
 // Start listening on http and private http port concurrently
 func (s *Server) Start(ctx context.Context) error {
+	s.ruleManager.Start(ctx)
+
 	err := s.initListeners()
 	if err != nil {
 		return err
@@ -297,9 +333,47 @@ func (s *Server) Stop(ctx context.Context) error {
 
 	s.opampServer.Stop()
 
+	if s.ruleManager != nil {
+		s.ruleManager.Stop(ctx)
+	}
+
 	// stop usage manager
 	s.usageManager.Stop(ctx)
 
 	return nil
 }
 
+func makeRulesManager(cache cache.Cache, alertmanager alertmanager.Alertmanager, sqlstore sqlstore.SQLStore, telemetryStore telemetrystore.TelemetryStore, metadataStore telemetrytypes.MetadataStore, prometheus prometheus.Prometheus, orgGetter organization.Getter, ruleStateHistoryModule rulestatehistory.Module, querier querier.Querier, providerSettings factory.ProviderSettings, queryParser queryparser.QueryParser) (*baserules.Manager, error) {
+	ruleStore := sqlrulestore.NewRuleStore(sqlstore, queryParser, providerSettings)
+	maintenanceStore := sqlrulestore.NewMaintenanceStore(sqlstore)
+	// create manager opts
+	managerOpts := &baserules.ManagerOptions{
+		TelemetryStore:         telemetryStore,
+		MetadataStore:          metadataStore,
+		Prometheus:             prometheus,
+		Context:                context.Background(),
+		Querier:                querier,
+		Logger:                 providerSettings.Logger,
+		Cache:                  cache,
+		EvalDelay:              baseconst.GetEvalDelay(),
+		PrepareTaskFunc:        rules.PrepareTaskFunc,
+		PrepareTestRuleFunc:    rules.TestNotification,
+		Alertmanager:           alertmanager,
+		OrgGetter:              orgGetter,
+		RuleStore:              ruleStore,
+		MaintenanceStore:       maintenanceStore,
+		SQLStore:               sqlstore,
+		QueryParser:            queryParser,
+		RuleStateHistoryModule: ruleStateHistoryModule,
+	}
+
+	// create Manager
+	manager, err := baserules.NewManager(managerOpts)
+	if err != nil {
+		return nil, fmt.Errorf("rule manager error: %v", err)
+	}
+
+	slog.Info("rules manager is ready")
+
+	return manager, nil
+}

frontend/.eslintrc.cjs

@@ -213,6 +213,23 @@ module.exports = {
 				message:
 					'Avoid calling .getState() directly. Export a standalone action from the store instead.',
 			},
+			{
+				selector:
+					"CallExpression[callee.object.name='window'][callee.property.name='open']",
+				message:
+					'Do not call window.open() directly. ' +
+					"Use openInNewTab() from 'utils/navigation' for internal SigNoz paths. " +
+					"For intentional external URLs, use openExternalLink() from 'utils/navigation'. " +
+					'For unavoidable direct calls, add // eslint-disable-next-line with a reason.',
+			},
+			{
+				selector:
+					"AssignmentExpression[left.object.name='window'][left.property.name='href']",
+				message:
+					'Do not assign window.location.href for internal navigation. ' +
+					"Use history.push() or history.replace() from 'lib/history'. " +
+					'For external redirects (SSO, logout URLs), add // eslint-disable-next-line with a reason.',
+			},
 		],
 	},
 	overrides: [
@@ -265,5 +282,14 @@ module.exports = {
 				'no-restricted-syntax': 'off',
 			},
 		},
+		{
+			// navigation.ts and useSafeNavigate.ts are the canonical implementations that call
+			// window.open after computing a base-path-aware href. They are the only places
+			// allowed to call window.open directly.
+			files: ['src/utils/navigation.ts', 'src/hooks/useSafeNavigate.ts'],
+			rules: {
+				'no-restricted-syntax': 'off',
+			},
+		},
 	],
 };

frontend/example.env

@@ -6,3 +6,6 @@ VITE_APPCUES_APP_ID="appcess-app-id"
 VITE_PYLON_IDENTITY_SECRET="pylon-identity-secret"
 
 CI="1"
+
+# Uncomment to test sub-path deployment locally (e.g. app served at /signoz/).
+# VITE_BASE_PATH="/signoz/"

frontend/index.html

@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html lang="en">
 	<head>
+		<base href="<%- BASE_PATH %>" />
 		<meta charset="utf-8" />
 		<meta
 			http-equiv="Cache-Control"
@@ -59,7 +60,7 @@
 		<meta data-react-helmet="true" name="docusaurus_locale" content="en" />
 		<meta data-react-helmet="true" name="docusaurus_tag" content="default" />
 		<meta name="robots" content="noindex" />
-		<link data-react-helmet="true" rel="shortcut icon" href="/favicon.ico" />
+		<link data-react-helmet="true" rel="shortcut icon" href="./favicon.ico" />
 	</head>
 	<body data-theme="default">
 		<noscript>You need to enable JavaScript to run this app.</noscript>
@@ -113,7 +114,7 @@
 				})(document, 'script');
 			}
 		</script>
-		<link rel="stylesheet" href="/css/uPlot.min.css" />
+		<link rel="stylesheet" href="./css/uPlot.min.css" />
 		<script type="module" src="./src/index.tsx"></script>
 	</body>
 </html>

frontend/jest.config.ts

@@ -20,6 +20,7 @@ const config: Config.InitialOptions = {
 		'^@signozhq/resizable$': '<rootDir>/__mocks__/resizableMock.tsx',
 		'^hooks/useSafeNavigate$': USE_SAFE_NAVIGATE_MOCK_PATH,
 		'^src/hooks/useSafeNavigate$': USE_SAFE_NAVIGATE_MOCK_PATH,
+		'^hooks/useSafeNavigate\\.impl$': '<rootDir>/src/hooks/useSafeNavigate.ts',
 		'^.*/useSafeNavigate$': USE_SAFE_NAVIGATE_MOCK_PATH,
 		'^constants/env$': '<rootDir>/__mocks__/env.ts',
 		'^src/constants/env$': '<rootDir>/__mocks__/env.ts',

frontend/src/api/alerts/create.ts

@@ -0,0 +1,20 @@
+import axios from 'api';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { PayloadProps, Props } from 'types/api/alerts/create';
+
+const create = async (
+	props: Props,
+): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
+	const response = await axios.post('/rules', {
+		...props.data,
+	});
+
+	return {
+		statusCode: 200,
+		error: null,
+		message: response.data.status,
+		payload: response.data.data,
+	};
+};
+
+export default create;

frontend/src/api/alerts/createAlertRule.ts

@@ -0,0 +1,28 @@
+import axios from 'api';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import {
+	AlertRuleV2,
+	PostableAlertRuleV2,
+} from 'types/api/alerts/alertTypesV2';
+
+export interface CreateAlertRuleResponse {
+	data: AlertRuleV2;
+	status: string;
+}
+
+const createAlertRule = async (
+	props: PostableAlertRuleV2,
+): Promise<SuccessResponse<CreateAlertRuleResponse> | ErrorResponse> => {
+	const response = await axios.post(`/rules`, {
+		...props,
+	});
+
+	return {
+		statusCode: 200,
+		error: null,
+		message: response.data.status,
+		payload: response.data.data,
+	};
+};
+
+export default createAlertRule;

frontend/src/api/alerts/delete.ts

@@ -0,0 +1,18 @@
+import axios from 'api';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { PayloadProps, Props } from 'types/api/alerts/delete';
+
+const deleteAlerts = async (
+	props: Props,
+): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
+	const response = await axios.delete(`/rules/${props.id}`);
+
+	return {
+		statusCode: 200,
+		error: null,
+		message: response.data.status,
+		payload: response.data.data.rules,
+	};
+};
+
+export default deleteAlerts;

frontend/src/api/alerts/get.ts

@@ -0,0 +1,16 @@
+import axios from 'api';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { PayloadProps, Props } from 'types/api/alerts/get';
+
+const get = async (
+	props: Props,
+): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
+	const response = await axios.get(`/rules/${props.id}`);
+	return {
+		statusCode: 200,
+		error: null,
+		message: response.data.status,
+		payload: response.data,
+	};
+};
+export default get;

frontend/src/api/alerts/getAll.ts

@@ -0,0 +1,24 @@
+import axios from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { PayloadProps } from 'types/api/alerts/getAll';
+
+const getAll = async (): Promise<
+	SuccessResponse<PayloadProps> | ErrorResponse
+> => {
+	try {
+		const response = await axios.get('/rules');
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data.data.rules,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};
+
+export default getAll;

frontend/src/api/alerts/getGroup.ts

@@ -0,0 +1,29 @@
+import { AxiosAlertManagerInstance } from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import convertObjectIntoParams from 'lib/query/convertObjectIntoParams';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { PayloadProps, Props } from 'types/api/alerts/getGroups';
+
+const getGroups = async (
+	props: Props,
+): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
+	try {
+		const queryParams = convertObjectIntoParams(props);
+
+		const response = await AxiosAlertManagerInstance.get(
+			`/alerts/groups?${queryParams}`,
+		);
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};
+
+export default getGroups;

frontend/src/api/alerts/patch.ts

@@ -0,0 +1,20 @@
+import axios from 'api';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { PayloadProps, Props } from 'types/api/alerts/patch';
+
+const patch = async (
+	props: Props,
+): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
+	const response = await axios.patch(`/rules/${props.id}`, {
+		...props.data,
+	});
+
+	return {
+		statusCode: 200,
+		error: null,
+		message: response.data.status,
+		payload: response.data.data,
+	};
+};
+
+export default patch;

frontend/src/api/alerts/put.ts

@@ -0,0 +1,20 @@
+import axios from 'api';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { PayloadProps, Props } from 'types/api/alerts/save';
+
+const put = async (
+	props: Props,
+): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
+	const response = await axios.put(`/rules/${props.id}`, {
+		...props.data,
+	});
+
+	return {
+		statusCode: 200,
+		error: null,
+		message: response.data.status,
+		payload: response.data.data,
+	};
+};
+
+export default put;

frontend/src/api/alerts/save.ts

@@ -0,0 +1,18 @@
+import { isEmpty } from 'lodash-es';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { PayloadProps, Props } from 'types/api/alerts/save';
+
+import create from './create';
+import put from './put';
+
+const save = async (
+	props: Props,
+): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
+	if (props.id && !isEmpty(props.id)) {
+		return put({ ...props });
+	}
+
+	return create({ ...props });
+};
+
+export default save;

frontend/src/api/alerts/testAlert.ts

@@ -0,0 +1,26 @@
+import axios from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { PayloadProps, Props } from 'types/api/alerts/testAlert';
+
+const testAlert = async (
+	props: Props,
+): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
+	try {
+		const response = await axios.post('/testRule', {
+			...props.data,
+		});
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};
+
+export default testAlert;

frontend/src/api/alerts/testAlertRule.ts

@@ -0,0 +1,28 @@
+import axios from 'api';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { PostableAlertRuleV2 } from 'types/api/alerts/alertTypesV2';
+
+export interface TestAlertRuleResponse {
+	data: {
+		alertCount: number;
+		message: string;
+	};
+	status: string;
+}
+
+const testAlertRule = async (
+	props: PostableAlertRuleV2,
+): Promise<SuccessResponse<TestAlertRuleResponse> | ErrorResponse> => {
+	const response = await axios.post(`/testRule`, {
+		...props,
+	});
+
+	return {
+		statusCode: 200,
+		error: null,
+		message: response.data.status,
+		payload: response.data.data,
+	};
+};
+
+export default testAlertRule;

frontend/src/api/alerts/updateAlertRule.ts

@@ -0,0 +1,26 @@
+import axios from 'api';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { PostableAlertRuleV2 } from 'types/api/alerts/alertTypesV2';
+
+export interface UpdateAlertRuleResponse {
+	data: string;
+	status: string;
+}
+
+const updateAlertRule = async (
+	id: string,
+	postableAlertRule: PostableAlertRuleV2,
+): Promise<SuccessResponse<UpdateAlertRuleResponse> | ErrorResponse> => {
+	const response = await axios.put(`/rules/${id}`, {
+		...postableAlertRule,
+	});
+
+	return {
+		statusCode: 200,
+		error: null,
+		message: response.data.status,
+		payload: response.data.data,
+	};
+};
+
+export default updateAlertRule;

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

@@ -1,97 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'yarn generate:api'
- * SigNoz
- */
-import type {
-	InvalidateOptions,
-	QueryClient,
-	QueryFunction,
-	QueryKey,
-	UseQueryOptions,
-	UseQueryResult,
-} from 'react-query';
-import { useQuery } from 'react-query';
-
-import type { ErrorType } from '../../../generatedAPIInstance';
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type { GetAlerts200, RenderErrorResponseDTO } from '../sigNoz.schemas';
-
-/**
- * This endpoint returns alerts for the organization
- * @summary Get alerts
- */
-export const getAlerts = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<GetAlerts200>({
-		url: `/api/v1/alerts`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetAlertsQueryKey = () => {
-	return [`/api/v1/alerts`] as const;
-};
-
-export const getGetAlertsQueryOptions = <
-	TData = Awaited<ReturnType<typeof getAlerts>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(options?: {
-	query?: UseQueryOptions<Awaited<ReturnType<typeof getAlerts>>, TError, TData>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getGetAlertsQueryKey();
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof getAlerts>>> = ({
-		signal,
-	}) => getAlerts(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof getAlerts>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetAlertsQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getAlerts>>
->;
-export type GetAlertsQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get alerts
- */
-
-export function useGetAlerts<
-	TData = Awaited<ReturnType<typeof getAlerts>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(options?: {
-	query?: UseQueryOptions<Awaited<ReturnType<typeof getAlerts>>, TError, TData>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetAlertsQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get alerts
- */
-export const invalidateGetAlerts = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetAlertsQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};

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

@@ -1,646 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'yarn generate:api'
- * SigNoz
- */
-import type {
-	InvalidateOptions,
-	MutationFunction,
-	QueryClient,
-	QueryFunction,
-	QueryKey,
-	UseMutationOptions,
-	UseMutationResult,
-	UseQueryOptions,
-	UseQueryResult,
-} from 'react-query';
-import { useMutation, useQuery } from 'react-query';
-
-import type { BodyType, ErrorType } from '../../../generatedAPIInstance';
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type {
-	ConfigReceiverDTO,
-	CreateChannel201,
-	DeleteChannelByIDPathParameters,
-	GetChannelByID200,
-	GetChannelByIDPathParameters,
-	ListChannels200,
-	RenderErrorResponseDTO,
-	UpdateChannelByIDPathParameters,
-} from '../sigNoz.schemas';
-
-/**
- * This endpoint lists all notification channels for the organization
- * @summary List notification channels
- */
-export const listChannels = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<ListChannels200>({
-		url: `/api/v1/channels`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getListChannelsQueryKey = () => {
-	return [`/api/v1/channels`] as const;
-};
-
-export const getListChannelsQueryOptions = <
-	TData = Awaited<ReturnType<typeof listChannels>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof listChannels>>,
-		TError,
-		TData
-	>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getListChannelsQueryKey();
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof listChannels>>> = ({
-		signal,
-	}) => listChannels(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listChannels>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListChannelsQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listChannels>>
->;
-export type ListChannelsQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List notification channels
- */
-
-export function useListChannels<
-	TData = Awaited<ReturnType<typeof listChannels>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof listChannels>>,
-		TError,
-		TData
-	>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListChannelsQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary List notification channels
- */
-export const invalidateListChannels = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListChannelsQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint creates a notification channel
- * @summary Create notification channel
- */
-export const createChannel = (
-	configReceiverDTO: BodyType<ConfigReceiverDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateChannel201>({
-		url: `/api/v1/channels`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: configReceiverDTO,
-		signal,
-	});
-};
-
-export const getCreateChannelMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createChannel>>,
-		TError,
-		{ data: BodyType<ConfigReceiverDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createChannel>>,
-	TError,
-	{ data: BodyType<ConfigReceiverDTO> },
-	TContext
-> => {
-	const mutationKey = ['createChannel'];
-	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 createChannel>>,
-		{ data: BodyType<ConfigReceiverDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return createChannel(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateChannelMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createChannel>>
->;
-export type CreateChannelMutationBody = BodyType<ConfigReceiverDTO>;
-export type CreateChannelMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create notification channel
- */
-export const useCreateChannel = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createChannel>>,
-		TError,
-		{ data: BodyType<ConfigReceiverDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createChannel>>,
-	TError,
-	{ data: BodyType<ConfigReceiverDTO> },
-	TContext
-> => {
-	const mutationOptions = getCreateChannelMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * This endpoint deletes a notification channel by ID
- * @summary Delete notification channel
- */
-export const deleteChannelByID = ({ id }: DeleteChannelByIDPathParameters) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/channels/${id}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeleteChannelByIDMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteChannelByID>>,
-		TError,
-		{ pathParams: DeleteChannelByIDPathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteChannelByID>>,
-	TError,
-	{ pathParams: DeleteChannelByIDPathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteChannelByID'];
-	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 deleteChannelByID>>,
-		{ pathParams: DeleteChannelByIDPathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteChannelByID(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteChannelByIDMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteChannelByID>>
->;
-
-export type DeleteChannelByIDMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete notification channel
- */
-export const useDeleteChannelByID = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteChannelByID>>,
-		TError,
-		{ pathParams: DeleteChannelByIDPathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteChannelByID>>,
-	TError,
-	{ pathParams: DeleteChannelByIDPathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeleteChannelByIDMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * This endpoint returns a notification channel by ID
- * @summary Get notification channel by ID
- */
-export const getChannelByID = (
-	{ id }: GetChannelByIDPathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetChannelByID200>({
-		url: `/api/v1/channels/${id}`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetChannelByIDQueryKey = ({
-	id,
-}: GetChannelByIDPathParameters) => {
-	return [`/api/v1/channels/${id}`] as const;
-};
-
-export const getGetChannelByIDQueryOptions = <
-	TData = Awaited<ReturnType<typeof getChannelByID>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetChannelByIDPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getChannelByID>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getGetChannelByIDQueryKey({ id });
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof getChannelByID>>> = ({
-		signal,
-	}) => getChannelByID({ id }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getChannelByID>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetChannelByIDQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getChannelByID>>
->;
-export type GetChannelByIDQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get notification channel by ID
- */
-
-export function useGetChannelByID<
-	TData = Awaited<ReturnType<typeof getChannelByID>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetChannelByIDPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getChannelByID>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetChannelByIDQueryOptions({ id }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get notification channel by ID
- */
-export const invalidateGetChannelByID = async (
-	queryClient: QueryClient,
-	{ id }: GetChannelByIDPathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetChannelByIDQueryKey({ id }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint updates a notification channel by ID
- * @summary Update notification channel
- */
-export const updateChannelByID = (
-	{ id }: UpdateChannelByIDPathParameters,
-	configReceiverDTO: BodyType<ConfigReceiverDTO>,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/channels/${id}`,
-		method: 'PUT',
-		headers: { 'Content-Type': 'application/json' },
-		data: configReceiverDTO,
-	});
-};
-
-export const getUpdateChannelByIDMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateChannelByID>>,
-		TError,
-		{
-			pathParams: UpdateChannelByIDPathParameters;
-			data: BodyType<ConfigReceiverDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateChannelByID>>,
-	TError,
-	{
-		pathParams: UpdateChannelByIDPathParameters;
-		data: BodyType<ConfigReceiverDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateChannelByID'];
-	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 updateChannelByID>>,
-		{
-			pathParams: UpdateChannelByIDPathParameters;
-			data: BodyType<ConfigReceiverDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateChannelByID(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateChannelByIDMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateChannelByID>>
->;
-export type UpdateChannelByIDMutationBody = BodyType<ConfigReceiverDTO>;
-export type UpdateChannelByIDMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update notification channel
- */
-export const useUpdateChannelByID = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateChannelByID>>,
-		TError,
-		{
-			pathParams: UpdateChannelByIDPathParameters;
-			data: BodyType<ConfigReceiverDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateChannelByID>>,
-	TError,
-	{
-		pathParams: UpdateChannelByIDPathParameters;
-		data: BodyType<ConfigReceiverDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getUpdateChannelByIDMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * This endpoint tests a notification channel by sending a test notification
- * @summary Test notification channel
- */
-export const testChannel = (
-	configReceiverDTO: BodyType<ConfigReceiverDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/channels/test`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: configReceiverDTO,
-		signal,
-	});
-};
-
-export const getTestChannelMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof testChannel>>,
-		TError,
-		{ data: BodyType<ConfigReceiverDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof testChannel>>,
-	TError,
-	{ data: BodyType<ConfigReceiverDTO> },
-	TContext
-> => {
-	const mutationKey = ['testChannel'];
-	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 testChannel>>,
-		{ data: BodyType<ConfigReceiverDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return testChannel(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type TestChannelMutationResult = NonNullable<
-	Awaited<ReturnType<typeof testChannel>>
->;
-export type TestChannelMutationBody = BodyType<ConfigReceiverDTO>;
-export type TestChannelMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Test notification channel
- */
-export const useTestChannel = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof testChannel>>,
-		TError,
-		{ data: BodyType<ConfigReceiverDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof testChannel>>,
-	TError,
-	{ data: BodyType<ConfigReceiverDTO> },
-	TContext
-> => {
-	const mutationOptions = getTestChannelMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Deprecated: use /api/v1/channels/test instead
- * @deprecated
- * @summary Test notification channel (deprecated)
- */
-export const testChannelDeprecated = (
-	configReceiverDTO: BodyType<ConfigReceiverDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/testChannel`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: configReceiverDTO,
-		signal,
-	});
-};
-
-export const getTestChannelDeprecatedMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof testChannelDeprecated>>,
-		TError,
-		{ data: BodyType<ConfigReceiverDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof testChannelDeprecated>>,
-	TError,
-	{ data: BodyType<ConfigReceiverDTO> },
-	TContext
-> => {
-	const mutationKey = ['testChannelDeprecated'];
-	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 testChannelDeprecated>>,
-		{ data: BodyType<ConfigReceiverDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return testChannelDeprecated(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type TestChannelDeprecatedMutationResult = NonNullable<
-	Awaited<ReturnType<typeof testChannelDeprecated>>
->;
-export type TestChannelDeprecatedMutationBody = BodyType<ConfigReceiverDTO>;
-export type TestChannelDeprecatedMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @deprecated
- * @summary Test notification channel (deprecated)
- */
-export const useTestChannelDeprecated = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof testChannelDeprecated>>,
-		TError,
-		{ data: BodyType<ConfigReceiverDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof testChannelDeprecated>>,
-	TError,
-	{ data: BodyType<ConfigReceiverDTO> },
-	TContext
-> => {
-	const mutationOptions = getTestChannelDeprecatedMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};

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

@@ -1,495 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'yarn generate:api'
- * SigNoz
- */
-import type {
-	InvalidateOptions,
-	MutationFunction,
-	QueryClient,
-	QueryFunction,
-	QueryKey,
-	UseMutationOptions,
-	UseMutationResult,
-	UseQueryOptions,
-	UseQueryResult,
-} from 'react-query';
-import { useMutation, useQuery } from 'react-query';
-
-import type { BodyType, ErrorType } from '../../../generatedAPIInstance';
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type {
-	DeleteDowntimeScheduleByIDPathParameters,
-	GetDowntimeScheduleByID200,
-	GetDowntimeScheduleByIDPathParameters,
-	ListDowntimeSchedules200,
-	ListDowntimeSchedulesParams,
-	RenderErrorResponseDTO,
-	RuletypesGettablePlannedMaintenanceDTO,
-	UpdateDowntimeScheduleByIDPathParameters,
-} from '../sigNoz.schemas';
-
-/**
- * This endpoint lists all planned maintenance / downtime schedules
- * @summary List downtime schedules
- */
-export const listDowntimeSchedules = (
-	params?: ListDowntimeSchedulesParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListDowntimeSchedules200>({
-		url: `/api/v1/downtime_schedules`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getListDowntimeSchedulesQueryKey = (
-	params?: ListDowntimeSchedulesParams,
-) => {
-	return [`/api/v1/downtime_schedules`, ...(params ? [params] : [])] as const;
-};
-
-export const getListDowntimeSchedulesQueryOptions = <
-	TData = Awaited<ReturnType<typeof listDowntimeSchedules>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	params?: ListDowntimeSchedulesParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listDowntimeSchedules>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getListDowntimeSchedulesQueryKey(params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof listDowntimeSchedules>>
-	> = ({ signal }) => listDowntimeSchedules(params, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listDowntimeSchedules>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListDowntimeSchedulesQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listDowntimeSchedules>>
->;
-export type ListDowntimeSchedulesQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List downtime schedules
- */
-
-export function useListDowntimeSchedules<
-	TData = Awaited<ReturnType<typeof listDowntimeSchedules>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	params?: ListDowntimeSchedulesParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listDowntimeSchedules>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListDowntimeSchedulesQueryOptions(params, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary List downtime schedules
- */
-export const invalidateListDowntimeSchedules = async (
-	queryClient: QueryClient,
-	params?: ListDowntimeSchedulesParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListDowntimeSchedulesQueryKey(params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint creates a new planned maintenance / downtime schedule
- * @summary Create downtime schedule
- */
-export const createDowntimeSchedule = (
-	ruletypesGettablePlannedMaintenanceDTO: BodyType<RuletypesGettablePlannedMaintenanceDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/downtime_schedules`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: ruletypesGettablePlannedMaintenanceDTO,
-		signal,
-	});
-};
-
-export const getCreateDowntimeScheduleMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createDowntimeSchedule>>,
-		TError,
-		{ data: BodyType<RuletypesGettablePlannedMaintenanceDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createDowntimeSchedule>>,
-	TError,
-	{ data: BodyType<RuletypesGettablePlannedMaintenanceDTO> },
-	TContext
-> => {
-	const mutationKey = ['createDowntimeSchedule'];
-	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 createDowntimeSchedule>>,
-		{ data: BodyType<RuletypesGettablePlannedMaintenanceDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return createDowntimeSchedule(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateDowntimeScheduleMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createDowntimeSchedule>>
->;
-export type CreateDowntimeScheduleMutationBody = BodyType<RuletypesGettablePlannedMaintenanceDTO>;
-export type CreateDowntimeScheduleMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create downtime schedule
- */
-export const useCreateDowntimeSchedule = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createDowntimeSchedule>>,
-		TError,
-		{ data: BodyType<RuletypesGettablePlannedMaintenanceDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createDowntimeSchedule>>,
-	TError,
-	{ data: BodyType<RuletypesGettablePlannedMaintenanceDTO> },
-	TContext
-> => {
-	const mutationOptions = getCreateDowntimeScheduleMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * This endpoint deletes a downtime schedule by ID
- * @summary Delete downtime schedule
- */
-export const deleteDowntimeScheduleByID = ({
-	id,
-}: DeleteDowntimeScheduleByIDPathParameters) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/downtime_schedules/${id}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeleteDowntimeScheduleByIDMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteDowntimeScheduleByID>>,
-		TError,
-		{ pathParams: DeleteDowntimeScheduleByIDPathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteDowntimeScheduleByID>>,
-	TError,
-	{ pathParams: DeleteDowntimeScheduleByIDPathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteDowntimeScheduleByID'];
-	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 deleteDowntimeScheduleByID>>,
-		{ pathParams: DeleteDowntimeScheduleByIDPathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteDowntimeScheduleByID(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteDowntimeScheduleByIDMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteDowntimeScheduleByID>>
->;
-
-export type DeleteDowntimeScheduleByIDMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete downtime schedule
- */
-export const useDeleteDowntimeScheduleByID = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteDowntimeScheduleByID>>,
-		TError,
-		{ pathParams: DeleteDowntimeScheduleByIDPathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteDowntimeScheduleByID>>,
-	TError,
-	{ pathParams: DeleteDowntimeScheduleByIDPathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeleteDowntimeScheduleByIDMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * This endpoint returns a downtime schedule by ID
- * @summary Get downtime schedule by ID
- */
-export const getDowntimeScheduleByID = (
-	{ id }: GetDowntimeScheduleByIDPathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetDowntimeScheduleByID200>({
-		url: `/api/v1/downtime_schedules/${id}`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetDowntimeScheduleByIDQueryKey = ({
-	id,
-}: GetDowntimeScheduleByIDPathParameters) => {
-	return [`/api/v1/downtime_schedules/${id}`] as const;
-};
-
-export const getGetDowntimeScheduleByIDQueryOptions = <
-	TData = Awaited<ReturnType<typeof getDowntimeScheduleByID>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetDowntimeScheduleByIDPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getDowntimeScheduleByID>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getGetDowntimeScheduleByIDQueryKey({ id });
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getDowntimeScheduleByID>>
-	> = ({ signal }) => getDowntimeScheduleByID({ id }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getDowntimeScheduleByID>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetDowntimeScheduleByIDQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getDowntimeScheduleByID>>
->;
-export type GetDowntimeScheduleByIDQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get downtime schedule by ID
- */
-
-export function useGetDowntimeScheduleByID<
-	TData = Awaited<ReturnType<typeof getDowntimeScheduleByID>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetDowntimeScheduleByIDPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getDowntimeScheduleByID>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetDowntimeScheduleByIDQueryOptions({ id }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get downtime schedule by ID
- */
-export const invalidateGetDowntimeScheduleByID = async (
-	queryClient: QueryClient,
-	{ id }: GetDowntimeScheduleByIDPathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetDowntimeScheduleByIDQueryKey({ id }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint updates a downtime schedule by ID
- * @summary Update downtime schedule
- */
-export const updateDowntimeScheduleByID = (
-	{ id }: UpdateDowntimeScheduleByIDPathParameters,
-	ruletypesGettablePlannedMaintenanceDTO: BodyType<RuletypesGettablePlannedMaintenanceDTO>,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/downtime_schedules/${id}`,
-		method: 'PUT',
-		headers: { 'Content-Type': 'application/json' },
-		data: ruletypesGettablePlannedMaintenanceDTO,
-	});
-};
-
-export const getUpdateDowntimeScheduleByIDMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateDowntimeScheduleByID>>,
-		TError,
-		{
-			pathParams: UpdateDowntimeScheduleByIDPathParameters;
-			data: BodyType<RuletypesGettablePlannedMaintenanceDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateDowntimeScheduleByID>>,
-	TError,
-	{
-		pathParams: UpdateDowntimeScheduleByIDPathParameters;
-		data: BodyType<RuletypesGettablePlannedMaintenanceDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateDowntimeScheduleByID'];
-	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 updateDowntimeScheduleByID>>,
-		{
-			pathParams: UpdateDowntimeScheduleByIDPathParameters;
-			data: BodyType<RuletypesGettablePlannedMaintenanceDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateDowntimeScheduleByID(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateDowntimeScheduleByIDMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateDowntimeScheduleByID>>
->;
-export type UpdateDowntimeScheduleByIDMutationBody = BodyType<RuletypesGettablePlannedMaintenanceDTO>;
-export type UpdateDowntimeScheduleByIDMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update downtime schedule
- */
-export const useUpdateDowntimeScheduleByID = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateDowntimeScheduleByID>>,
-		TError,
-		{
-			pathParams: UpdateDowntimeScheduleByIDPathParameters;
-			data: BodyType<RuletypesGettablePlannedMaintenanceDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateDowntimeScheduleByID>>,
-	TError,
-	{
-		pathParams: UpdateDowntimeScheduleByIDPathParameters;
-		data: BodyType<RuletypesGettablePlannedMaintenanceDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getUpdateDowntimeScheduleByIDMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};

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

@@ -1,482 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'yarn generate:api'
- * SigNoz
- */
-import type {
-	InvalidateOptions,
-	MutationFunction,
-	QueryClient,
-	QueryFunction,
-	QueryKey,
-	UseMutationOptions,
-	UseMutationResult,
-	UseQueryOptions,
-	UseQueryResult,
-} from 'react-query';
-import { useMutation, useQuery } from 'react-query';
-
-import type { BodyType, ErrorType } from '../../../generatedAPIInstance';
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type {
-	AlertmanagertypesPostableRoutePolicyDTO,
-	CreateRoutePolicy201,
-	DeleteRoutePolicyByIDPathParameters,
-	GetAllRoutePolicies200,
-	GetRoutePolicyByID200,
-	GetRoutePolicyByIDPathParameters,
-	RenderErrorResponseDTO,
-	UpdateRoutePolicy200,
-	UpdateRoutePolicyPathParameters,
-} from '../sigNoz.schemas';
-
-/**
- * This endpoint lists all route policies for the organization
- * @summary List route policies
- */
-export const getAllRoutePolicies = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<GetAllRoutePolicies200>({
-		url: `/api/v1/route_policies`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetAllRoutePoliciesQueryKey = () => {
-	return [`/api/v1/route_policies`] as const;
-};
-
-export const getGetAllRoutePoliciesQueryOptions = <
-	TData = Awaited<ReturnType<typeof getAllRoutePolicies>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof getAllRoutePolicies>>,
-		TError,
-		TData
-	>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getGetAllRoutePoliciesQueryKey();
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getAllRoutePolicies>>
-	> = ({ signal }) => getAllRoutePolicies(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof getAllRoutePolicies>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetAllRoutePoliciesQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getAllRoutePolicies>>
->;
-export type GetAllRoutePoliciesQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List route policies
- */
-
-export function useGetAllRoutePolicies<
-	TData = Awaited<ReturnType<typeof getAllRoutePolicies>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof getAllRoutePolicies>>,
-		TError,
-		TData
-	>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetAllRoutePoliciesQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary List route policies
- */
-export const invalidateGetAllRoutePolicies = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetAllRoutePoliciesQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint creates a route policy
- * @summary Create route policy
- */
-export const createRoutePolicy = (
-	alertmanagertypesPostableRoutePolicyDTO: BodyType<AlertmanagertypesPostableRoutePolicyDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateRoutePolicy201>({
-		url: `/api/v1/route_policies`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: alertmanagertypesPostableRoutePolicyDTO,
-		signal,
-	});
-};
-
-export const getCreateRoutePolicyMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createRoutePolicy>>,
-		TError,
-		{ data: BodyType<AlertmanagertypesPostableRoutePolicyDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createRoutePolicy>>,
-	TError,
-	{ data: BodyType<AlertmanagertypesPostableRoutePolicyDTO> },
-	TContext
-> => {
-	const mutationKey = ['createRoutePolicy'];
-	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 createRoutePolicy>>,
-		{ data: BodyType<AlertmanagertypesPostableRoutePolicyDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return createRoutePolicy(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateRoutePolicyMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createRoutePolicy>>
->;
-export type CreateRoutePolicyMutationBody = BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
-export type CreateRoutePolicyMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create route policy
- */
-export const useCreateRoutePolicy = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createRoutePolicy>>,
-		TError,
-		{ data: BodyType<AlertmanagertypesPostableRoutePolicyDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createRoutePolicy>>,
-	TError,
-	{ data: BodyType<AlertmanagertypesPostableRoutePolicyDTO> },
-	TContext
-> => {
-	const mutationOptions = getCreateRoutePolicyMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * This endpoint deletes a route policy by ID
- * @summary Delete route policy
- */
-export const deleteRoutePolicyByID = ({
-	id,
-}: DeleteRoutePolicyByIDPathParameters) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/route_policies/${id}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeleteRoutePolicyByIDMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteRoutePolicyByID>>,
-		TError,
-		{ pathParams: DeleteRoutePolicyByIDPathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteRoutePolicyByID>>,
-	TError,
-	{ pathParams: DeleteRoutePolicyByIDPathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteRoutePolicyByID'];
-	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 deleteRoutePolicyByID>>,
-		{ pathParams: DeleteRoutePolicyByIDPathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteRoutePolicyByID(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteRoutePolicyByIDMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteRoutePolicyByID>>
->;
-
-export type DeleteRoutePolicyByIDMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete route policy
- */
-export const useDeleteRoutePolicyByID = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteRoutePolicyByID>>,
-		TError,
-		{ pathParams: DeleteRoutePolicyByIDPathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteRoutePolicyByID>>,
-	TError,
-	{ pathParams: DeleteRoutePolicyByIDPathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeleteRoutePolicyByIDMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * This endpoint returns a route policy by ID
- * @summary Get route policy by ID
- */
-export const getRoutePolicyByID = (
-	{ id }: GetRoutePolicyByIDPathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetRoutePolicyByID200>({
-		url: `/api/v1/route_policies/${id}`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetRoutePolicyByIDQueryKey = ({
-	id,
-}: GetRoutePolicyByIDPathParameters) => {
-	return [`/api/v1/route_policies/${id}`] as const;
-};
-
-export const getGetRoutePolicyByIDQueryOptions = <
-	TData = Awaited<ReturnType<typeof getRoutePolicyByID>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetRoutePolicyByIDPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getRoutePolicyByID>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getGetRoutePolicyByIDQueryKey({ id });
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getRoutePolicyByID>>
-	> = ({ signal }) => getRoutePolicyByID({ id }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getRoutePolicyByID>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetRoutePolicyByIDQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getRoutePolicyByID>>
->;
-export type GetRoutePolicyByIDQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get route policy by ID
- */
-
-export function useGetRoutePolicyByID<
-	TData = Awaited<ReturnType<typeof getRoutePolicyByID>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetRoutePolicyByIDPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getRoutePolicyByID>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetRoutePolicyByIDQueryOptions({ id }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get route policy by ID
- */
-export const invalidateGetRoutePolicyByID = async (
-	queryClient: QueryClient,
-	{ id }: GetRoutePolicyByIDPathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetRoutePolicyByIDQueryKey({ id }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint updates a route policy by ID
- * @summary Update route policy
- */
-export const updateRoutePolicy = (
-	{ id }: UpdateRoutePolicyPathParameters,
-	alertmanagertypesPostableRoutePolicyDTO: BodyType<AlertmanagertypesPostableRoutePolicyDTO>,
-) => {
-	return GeneratedAPIInstance<UpdateRoutePolicy200>({
-		url: `/api/v1/route_policies/${id}`,
-		method: 'PUT',
-		headers: { 'Content-Type': 'application/json' },
-		data: alertmanagertypesPostableRoutePolicyDTO,
-	});
-};
-
-export const getUpdateRoutePolicyMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateRoutePolicy>>,
-		TError,
-		{
-			pathParams: UpdateRoutePolicyPathParameters;
-			data: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateRoutePolicy>>,
-	TError,
-	{
-		pathParams: UpdateRoutePolicyPathParameters;
-		data: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateRoutePolicy'];
-	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 updateRoutePolicy>>,
-		{
-			pathParams: UpdateRoutePolicyPathParameters;
-			data: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateRoutePolicy(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateRoutePolicyMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateRoutePolicy>>
->;
-export type UpdateRoutePolicyMutationBody = BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
-export type UpdateRoutePolicyMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update route policy
- */
-export const useUpdateRoutePolicy = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateRoutePolicy>>,
-		TError,
-		{
-			pathParams: UpdateRoutePolicyPathParameters;
-			data: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateRoutePolicy>>,
-	TError,
-	{
-		pathParams: UpdateRoutePolicyPathParameters;
-		data: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getUpdateRoutePolicyMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};

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

@@ -6,24 +6,17 @@
  */
 import type {
 	InvalidateOptions,
-	MutationFunction,
 	QueryClient,
 	QueryFunction,
 	QueryKey,
-	UseMutationOptions,
-	UseMutationResult,
 	UseQueryOptions,
 	UseQueryResult,
 } from 'react-query';
-import { useMutation, useQuery } from 'react-query';
+import { useQuery } from 'react-query';
 
-import type { BodyType, ErrorType } from '../../../generatedAPIInstance';
+import type { ErrorType } from '../../../generatedAPIInstance';
 import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
 import type {
-	CreateRule200,
-	DeleteRuleByIDPathParameters,
-	GetRuleByID200,
-	GetRuleByIDPathParameters,
 	GetRuleHistoryFilterKeys200,
 	GetRuleHistoryFilterKeysParams,
 	GetRuleHistoryFilterKeysPathParameters,
@@ -42,717 +35,9 @@ import type {
 	GetRuleHistoryTopContributors200,
 	GetRuleHistoryTopContributorsParams,
 	GetRuleHistoryTopContributorsPathParameters,
-	ListRules200,
-	PatchRuleByID200,
-	PatchRuleByIDPathParameters,
 	RenderErrorResponseDTO,
-	RuletypesPostableRuleDTO,
-	TestRule200,
-	TestRuleDeprecated200,
-	UpdateRuleByIDPathParameters,
 } from '../sigNoz.schemas';
 
-/**
- * This endpoint lists all alert rules with their current evaluation state
- * @summary List alert rules
- */
-export const listRules = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<ListRules200>({
-		url: `/api/v1/rules`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getListRulesQueryKey = () => {
-	return [`/api/v1/rules`] as const;
-};
-
-export const getListRulesQueryOptions = <
-	TData = Awaited<ReturnType<typeof listRules>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(options?: {
-	query?: UseQueryOptions<Awaited<ReturnType<typeof listRules>>, TError, TData>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getListRulesQueryKey();
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof listRules>>> = ({
-		signal,
-	}) => listRules(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listRules>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListRulesQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listRules>>
->;
-export type ListRulesQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List alert rules
- */
-
-export function useListRules<
-	TData = Awaited<ReturnType<typeof listRules>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(options?: {
-	query?: UseQueryOptions<Awaited<ReturnType<typeof listRules>>, TError, TData>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListRulesQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary List alert rules
- */
-export const invalidateListRules = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListRulesQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint creates a new alert rule
- * @summary Create alert rule
- */
-export const createRule = (
-	ruletypesPostableRuleDTO: BodyType<RuletypesPostableRuleDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateRule200>({
-		url: `/api/v1/rules`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: ruletypesPostableRuleDTO,
-		signal,
-	});
-};
-
-export const getCreateRuleMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createRule>>,
-		TError,
-		{ data: BodyType<RuletypesPostableRuleDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createRule>>,
-	TError,
-	{ data: BodyType<RuletypesPostableRuleDTO> },
-	TContext
-> => {
-	const mutationKey = ['createRule'];
-	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 createRule>>,
-		{ data: BodyType<RuletypesPostableRuleDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return createRule(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateRuleMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createRule>>
->;
-export type CreateRuleMutationBody = BodyType<RuletypesPostableRuleDTO>;
-export type CreateRuleMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create alert rule
- */
-export const useCreateRule = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createRule>>,
-		TError,
-		{ data: BodyType<RuletypesPostableRuleDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createRule>>,
-	TError,
-	{ data: BodyType<RuletypesPostableRuleDTO> },
-	TContext
-> => {
-	const mutationOptions = getCreateRuleMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * This endpoint deletes an alert rule by ID
- * @summary Delete alert rule
- */
-export const deleteRuleByID = ({ id }: DeleteRuleByIDPathParameters) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/rules/${id}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeleteRuleByIDMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteRuleByID>>,
-		TError,
-		{ pathParams: DeleteRuleByIDPathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteRuleByID>>,
-	TError,
-	{ pathParams: DeleteRuleByIDPathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteRuleByID'];
-	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 deleteRuleByID>>,
-		{ pathParams: DeleteRuleByIDPathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteRuleByID(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteRuleByIDMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteRuleByID>>
->;
-
-export type DeleteRuleByIDMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete alert rule
- */
-export const useDeleteRuleByID = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteRuleByID>>,
-		TError,
-		{ pathParams: DeleteRuleByIDPathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteRuleByID>>,
-	TError,
-	{ pathParams: DeleteRuleByIDPathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeleteRuleByIDMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * This endpoint returns an alert rule by ID
- * @summary Get alert rule by ID
- */
-export const getRuleByID = (
-	{ id }: GetRuleByIDPathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetRuleByID200>({
-		url: `/api/v1/rules/${id}`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetRuleByIDQueryKey = ({ id }: GetRuleByIDPathParameters) => {
-	return [`/api/v1/rules/${id}`] as const;
-};
-
-export const getGetRuleByIDQueryOptions = <
-	TData = Awaited<ReturnType<typeof getRuleByID>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetRuleByIDPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getRuleByID>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getGetRuleByIDQueryKey({ id });
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof getRuleByID>>> = ({
-		signal,
-	}) => getRuleByID({ id }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getRuleByID>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetRuleByIDQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getRuleByID>>
->;
-export type GetRuleByIDQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get alert rule by ID
- */
-
-export function useGetRuleByID<
-	TData = Awaited<ReturnType<typeof getRuleByID>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetRuleByIDPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getRuleByID>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetRuleByIDQueryOptions({ id }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get alert rule by ID
- */
-export const invalidateGetRuleByID = async (
-	queryClient: QueryClient,
-	{ id }: GetRuleByIDPathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetRuleByIDQueryKey({ id }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint applies a partial update to an alert rule by ID
- * @summary Patch alert rule
- */
-export const patchRuleByID = (
-	{ id }: PatchRuleByIDPathParameters,
-	ruletypesPostableRuleDTO: BodyType<RuletypesPostableRuleDTO>,
-) => {
-	return GeneratedAPIInstance<PatchRuleByID200>({
-		url: `/api/v1/rules/${id}`,
-		method: 'PATCH',
-		headers: { 'Content-Type': 'application/json' },
-		data: ruletypesPostableRuleDTO,
-	});
-};
-
-export const getPatchRuleByIDMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof patchRuleByID>>,
-		TError,
-		{
-			pathParams: PatchRuleByIDPathParameters;
-			data: BodyType<RuletypesPostableRuleDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof patchRuleByID>>,
-	TError,
-	{
-		pathParams: PatchRuleByIDPathParameters;
-		data: BodyType<RuletypesPostableRuleDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['patchRuleByID'];
-	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 patchRuleByID>>,
-		{
-			pathParams: PatchRuleByIDPathParameters;
-			data: BodyType<RuletypesPostableRuleDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return patchRuleByID(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type PatchRuleByIDMutationResult = NonNullable<
-	Awaited<ReturnType<typeof patchRuleByID>>
->;
-export type PatchRuleByIDMutationBody = BodyType<RuletypesPostableRuleDTO>;
-export type PatchRuleByIDMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Patch alert rule
- */
-export const usePatchRuleByID = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof patchRuleByID>>,
-		TError,
-		{
-			pathParams: PatchRuleByIDPathParameters;
-			data: BodyType<RuletypesPostableRuleDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof patchRuleByID>>,
-	TError,
-	{
-		pathParams: PatchRuleByIDPathParameters;
-		data: BodyType<RuletypesPostableRuleDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getPatchRuleByIDMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * This endpoint updates an alert rule by ID
- * @summary Update alert rule
- */
-export const updateRuleByID = (
-	{ id }: UpdateRuleByIDPathParameters,
-	ruletypesPostableRuleDTO: BodyType<RuletypesPostableRuleDTO>,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/rules/${id}`,
-		method: 'PUT',
-		headers: { 'Content-Type': 'application/json' },
-		data: ruletypesPostableRuleDTO,
-	});
-};
-
-export const getUpdateRuleByIDMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateRuleByID>>,
-		TError,
-		{
-			pathParams: UpdateRuleByIDPathParameters;
-			data: BodyType<RuletypesPostableRuleDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateRuleByID>>,
-	TError,
-	{
-		pathParams: UpdateRuleByIDPathParameters;
-		data: BodyType<RuletypesPostableRuleDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateRuleByID'];
-	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 updateRuleByID>>,
-		{
-			pathParams: UpdateRuleByIDPathParameters;
-			data: BodyType<RuletypesPostableRuleDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateRuleByID(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateRuleByIDMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateRuleByID>>
->;
-export type UpdateRuleByIDMutationBody = BodyType<RuletypesPostableRuleDTO>;
-export type UpdateRuleByIDMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update alert rule
- */
-export const useUpdateRuleByID = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateRuleByID>>,
-		TError,
-		{
-			pathParams: UpdateRuleByIDPathParameters;
-			data: BodyType<RuletypesPostableRuleDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateRuleByID>>,
-	TError,
-	{
-		pathParams: UpdateRuleByIDPathParameters;
-		data: BodyType<RuletypesPostableRuleDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getUpdateRuleByIDMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * This endpoint fires a test notification for the given rule definition
- * @summary Test alert rule
- */
-export const testRule = (
-	ruletypesPostableRuleDTO: BodyType<RuletypesPostableRuleDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<TestRule200>({
-		url: `/api/v1/rules/test`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: ruletypesPostableRuleDTO,
-		signal,
-	});
-};
-
-export const getTestRuleMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof testRule>>,
-		TError,
-		{ data: BodyType<RuletypesPostableRuleDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof testRule>>,
-	TError,
-	{ data: BodyType<RuletypesPostableRuleDTO> },
-	TContext
-> => {
-	const mutationKey = ['testRule'];
-	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 testRule>>,
-		{ data: BodyType<RuletypesPostableRuleDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return testRule(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type TestRuleMutationResult = NonNullable<
-	Awaited<ReturnType<typeof testRule>>
->;
-export type TestRuleMutationBody = BodyType<RuletypesPostableRuleDTO>;
-export type TestRuleMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Test alert rule
- */
-export const useTestRule = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof testRule>>,
-		TError,
-		{ data: BodyType<RuletypesPostableRuleDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof testRule>>,
-	TError,
-	{ data: BodyType<RuletypesPostableRuleDTO> },
-	TContext
-> => {
-	const mutationOptions = getTestRuleMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Deprecated: use /api/v1/rules/test instead
- * @deprecated
- * @summary Test alert rule (deprecated)
- */
-export const testRuleDeprecated = (
-	ruletypesPostableRuleDTO: BodyType<RuletypesPostableRuleDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<TestRuleDeprecated200>({
-		url: `/api/v1/testRule`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: ruletypesPostableRuleDTO,
-		signal,
-	});
-};
-
-export const getTestRuleDeprecatedMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof testRuleDeprecated>>,
-		TError,
-		{ data: BodyType<RuletypesPostableRuleDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof testRuleDeprecated>>,
-	TError,
-	{ data: BodyType<RuletypesPostableRuleDTO> },
-	TContext
-> => {
-	const mutationKey = ['testRuleDeprecated'];
-	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 testRuleDeprecated>>,
-		{ data: BodyType<RuletypesPostableRuleDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return testRuleDeprecated(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type TestRuleDeprecatedMutationResult = NonNullable<
-	Awaited<ReturnType<typeof testRuleDeprecated>>
->;
-export type TestRuleDeprecatedMutationBody = BodyType<RuletypesPostableRuleDTO>;
-export type TestRuleDeprecatedMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @deprecated
- * @summary Test alert rule (deprecated)
- */
-export const useTestRuleDeprecated = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof testRuleDeprecated>>,
-		TError,
-		{ data: BodyType<RuletypesPostableRuleDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof testRuleDeprecated>>,
-	TError,
-	{ data: BodyType<RuletypesPostableRuleDTO> },
-	TContext
-> => {
-	const mutationOptions = getTestRuleDeprecatedMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
 /**
  * Returns distinct label keys from rule history entries for the selected range.
  * @summary Get rule history filter keys

frontend/src/api/plannedDowntime/createDowntimeSchedule.ts

@@ -0,0 +1,45 @@
+import axios from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import { Dayjs } from 'dayjs';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+
+import { Recurrence } from './getAllDowntimeSchedules';
+
+export interface DowntimeSchedulePayload {
+	name: string;
+	description?: string;
+	alertIds: string[];
+	schedule: {
+		timezone?: string;
+		startTime?: string | Dayjs;
+		endTime?: string | Dayjs;
+		recurrence?: Recurrence;
+	};
+}
+
+export interface PayloadProps {
+	status: string;
+	data: string;
+}
+
+const createDowntimeSchedule = async (
+	props: DowntimeSchedulePayload,
+): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
+	try {
+		const response = await axios.post('/downtime_schedules', {
+			...props,
+		});
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};
+
+export default createDowntimeSchedule;

frontend/src/api/plannedDowntime/deleteDowntimeSchedule.ts

@@ -0,0 +1,19 @@
+import { useMutation, UseMutationResult } from 'react-query';
+import axios from 'api';
+
+export interface DeleteDowntimeScheduleProps {
+	id?: number;
+}
+
+export interface DeleteSchedulePayloadProps {
+	status: string;
+	data: string;
+}
+
+export const useDeleteDowntimeSchedule = (
+	props: DeleteDowntimeScheduleProps,
+): UseMutationResult<DeleteSchedulePayloadProps, Error, number> =>
+	useMutation({
+		mutationKey: [props.id],
+		mutationFn: () => axios.delete(`/downtime_schedules/${props.id}`),
+	});

frontend/src/api/plannedDowntime/getAllDowntimeSchedules.ts

@@ -0,0 +1,51 @@
+import { useQuery, UseQueryResult } from 'react-query';
+import axios from 'api';
+import { AxiosError, AxiosResponse } from 'axios';
+import { Option } from 'container/PlannedDowntime/PlannedDowntimeutils';
+
+export type Recurrence = {
+	startTime?: string | null;
+	endTime?: string | null;
+	duration?: number | string | null;
+	repeatType?: string | Option | null;
+	repeatOn?: string[] | null;
+};
+
+type Schedule = {
+	timezone: string | null;
+	startTime: string | null;
+	endTime: string | null;
+	recurrence: Recurrence | null;
+};
+
+export interface DowntimeSchedules {
+	id: number;
+	name: string | null;
+	description: string | null;
+	schedule: Schedule | null;
+	alertIds: string[] | null;
+	createdAt: string | null;
+	createdBy: string | null;
+	updatedAt: string | null;
+	updatedBy: string | null;
+	kind: string | null;
+}
+export type PayloadProps = { data: DowntimeSchedules[] };
+
+export const getAllDowntimeSchedules = async (
+	props?: GetAllDowntimeSchedulesPayloadProps,
+): Promise<AxiosResponse<PayloadProps>> =>
+	axios.get('/downtime_schedules', { params: props });
+
+export interface GetAllDowntimeSchedulesPayloadProps {
+	active?: boolean;
+	recurrence?: boolean;
+}
+
+export const useGetAllDowntimeSchedules = (
+	props?: GetAllDowntimeSchedulesPayloadProps,
+): UseQueryResult<AxiosResponse<PayloadProps>, AxiosError> =>
+	useQuery<AxiosResponse<PayloadProps>, AxiosError>({
+		queryKey: ['getAllDowntimeSchedules', props],
+		queryFn: () => getAllDowntimeSchedules(props),
+	});

frontend/src/api/plannedDowntime/updateDowntimeSchedule.ts

@@ -0,0 +1,37 @@
+import axios from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+
+import { DowntimeSchedulePayload } from './createDowntimeSchedule';
+
+export interface DowntimeScheduleUpdatePayload {
+	data: DowntimeSchedulePayload;
+	id?: number;
+}
+
+export interface PayloadProps {
+	status: string;
+	data: string;
+}
+
+const updateDowntimeSchedule = async (
+	props: DowntimeScheduleUpdatePayload,
+): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
+	try {
+		const response = await axios.put(`/downtime_schedules/${props.id}`, {
+			...props.data,
+		});
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};
+
+export default updateDowntimeSchedule;

frontend/src/components/AuthPageContainer/AuthHeader.tsx

@@ -1,6 +1,7 @@
 import { useCallback } from 'react';
 import { Button } from '@signozhq/button';
 import { LifeBuoy } from 'lucide-react';
+import { openExternalLink } from 'utils/navigation';
 
 import signozBrandLogoUrl from '@/assets/Logos/signoz-brand-logo.svg';
 
@@ -8,7 +9,7 @@ import './AuthHeader.styles.scss';
 
 function AuthHeader(): JSX.Element {
 	const handleGetHelp = useCallback((): void => {
-		window.open('https://signoz.io/support/', '_blank');
+		openExternalLink('https://signoz.io/support/');
 	}, []);
 
 	return (

frontend/src/components/CeleryTask/useNavigateToExplorer.ts

@@ -7,11 +7,13 @@ import ROUTES from 'constants/routes';
 import useUpdatedQuery from 'container/GridCardLayout/useResolveQuery';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useNotifications } from 'hooks/useNotifications';
+import history from 'lib/history';
 import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { AppState } from 'store/reducers';
 import { Query, TagFilterItem } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource, MetricAggregateOperator } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 
 export interface NavigateToExplorerProps {
 	filters: TagFilterItem[];
@@ -133,7 +135,11 @@ export function useNavigateToExplorer(): (
 				QueryParams.compositeQuery
 			}=${JSONCompositeQuery}`;
 
-			window.open(newExplorerPath, sameTab ? '_self' : '_blank');
+			if (sameTab) {
+				history.push(newExplorerPath);
+			} else {
+				openInNewTab(newExplorerPath);
+			}
 		},
 		[
 			prepareQuery,

frontend/src/components/ChangelogModal/ChangelogModal.tsx

@@ -11,6 +11,7 @@ import { ChevronsDown, ScrollText } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
 import { ChangelogSchema } from 'types/api/changelog/getChangelogByVersion';
 import { UserPreference } from 'types/api/preferences/preference';
+import { openExternalLink } from 'utils/navigation';
 
 import ChangelogRenderer from './components/ChangelogRenderer';
 
@@ -86,11 +87,7 @@ function ChangelogModal({ changelog, onClose }: Props): JSX.Element {
 	}, [checkScroll]);
 
 	const onClickUpdateWorkspace = (): void => {
-		window.open(
-			'https://signoz.io/upgrade-path',
-			'_blank',
-			'noopener,noreferrer',
-		);
+		openExternalLink('https://signoz.io/upgrade-path');
 	};
 
 	const onClickScrollForMore = (): void => {

frontend/src/components/HostMetricsDetail/HostMetricsDetails.tsx

@@ -50,6 +50,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import { VIEW_TYPES, VIEWS } from './constants';
@@ -330,10 +331,7 @@ function HostMetricsDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -352,10 +350,7 @@ function HostMetricsDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/components/LearnMore/LearnMore.tsx

@@ -1,6 +1,7 @@
 import { Color } from '@signozhq/design-tokens';
 import { Button } from 'antd';
 import { ArrowUpRight } from 'lucide-react';
+import { openExternalLink } from 'utils/navigation';
 
 import './LearnMore.styles.scss';
 
@@ -14,7 +15,7 @@ function LearnMore({ text, url, onClick }: LearnMoreProps): JSX.Element {
 	const handleClick = (): void => {
 		onClick?.();
 		if (url) {
-			window.open(url, '_blank');
+			openExternalLink(url);
 		}
 	};
 	return (

frontend/src/components/MessagingQueueHealthCheck/AttributeCheckList.tsx

@@ -20,6 +20,7 @@ import {
 	KAFKA_SETUP_DOC_LINK,
 	MessagingQueueHealthCheckService,
 } from 'pages/MessagingQueues/MessagingQueuesUtils';
+import { openExternalLink } from 'utils/navigation';
 import { v4 as uuid } from 'uuid';
 
 import './MessagingQueueHealthCheck.styles.scss';
@@ -76,7 +77,7 @@ function ErrorTitleAndKey({
 		if (isCloudUserVal && !!link) {
 			history.push(link);
 		} else {
-			window.open(KAFKA_SETUP_DOC_LINK, '_blank');
+			openExternalLink(KAFKA_SETUP_DOC_LINK);
 		}
 	};
 	return {

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/LogsQuickFilterEmptyState.tsx

@@ -2,6 +2,7 @@ import { Color } from '@signozhq/design-tokens';
 import { Button } from 'antd';
 import EmptyQuickFilterIcon from 'assets/CustomIcons/EmptyQuickFilterIcon';
 import { ArrowUpRight } from 'lucide-react';
+import { openExternalLink } from 'utils/navigation';
 
 const QUICK_FILTER_DOC_PATHS: Record<string, string> = {
 	severity_text: 'severity-text',
@@ -22,9 +23,8 @@ function LogsQuickFilterEmptyState({
 	const handleLearnMoreClick = (): void => {
 		const section = QUICK_FILTER_DOC_PATHS[attributeKey];
 
-		window.open(
+		openExternalLink(
 			`https://signoz.io/docs/logs-management/features/logs-quick-filters#${section}`,
-			'_blank',
 		);
 	};
 	return (

frontend/src/constants/localStorage.ts

@@ -37,5 +37,4 @@ export enum LOCALSTORAGE {
 	SHOW_FREQUENCY_CHART = 'SHOW_FREQUENCY_CHART',
 	DISSMISSED_COST_METER_INFO = 'DISMISSED_COST_METER_INFO',
 	DISMISSED_API_KEYS_DEPRECATION_BANNER = 'DISMISSED_API_KEYS_DEPRECATION_BANNER',
-	LICENSE_KEY_CALLOUT_DISMISSED = 'LICENSE_KEY_CALLOUT_DISMISSED',
 }

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/components/DependentServices.tsx

@@ -9,6 +9,7 @@ import {
 } from 'container/ApiMonitoring/utils';
 import { UnfoldVertical } from 'lucide-react';
 import { SuccessResponse } from 'types/api';
+import { openInNewTab } from 'utils/navigation';
 
 import emptyStateUrl from '@/assets/Icons/emptyState.svg';
 
@@ -107,7 +108,7 @@ function DependentServices({
 							urlQuery.set(QueryParams.startTime, timeRange.startTime.toString());
 							urlQuery.set(QueryParams.endTime, timeRange.endTime.toString());
 							url.search = urlQuery.toString();
-							window.open(url.toString(), '_blank');
+							openInNewTab(`${url.pathname}${url.search}`);
 						},
 						className: 'clickable-row',
 					})}

frontend/src/container/CreateAlertRule/SelectAlertType/index.tsx

@@ -7,6 +7,7 @@ import { FeatureKeys } from 'constants/features';
 import { useAppContext } from 'providers/App/App';
 import { AlertTypes } from 'types/api/alerts/alertTypes';
 import { isModifierKeyPressed } from 'utils/app';
+import { openExternalLink } from 'utils/navigation';
 
 import { getOptionList } from './config';
 import { AlertTypeCard, SelectTypeContainer } from './styles';
@@ -55,7 +56,7 @@ function SelectAlertType({ onSelect }: SelectAlertTypeProps): JSX.Element {
 			page: 'New alert data source selection page',
 		});
 
-		window.open(url, '_blank');
+		openExternalLink(url);
 	}
 	const renderOptions = useMemo(
 		() => (

frontend/src/container/CreateAlertV2/AlertCondition/utils.tsx

@@ -14,6 +14,7 @@ import { IUser } from 'providers/App/types';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
 import { USER_ROLES } from 'types/roles';
+import { openInNewTab } from 'utils/navigation';
 
 import { ROUTING_POLICIES_ROUTE } from './constants';
 import { RoutingPolicyBannerProps } from './types';
@@ -387,7 +388,7 @@ export function NotificationChannelsNotFoundContent({
 							style={{ padding: '0 4px' }}
 							type="link"
 							onClick={(): void => {
-								window.open(ROUTES.CHANNELS_NEW, '_blank');
+								openInNewTab(ROUTES.CHANNELS_NEW);
 							}}
 						>
 							here.

frontend/src/container/CreateAlertV2/CreateAlertHeader/__tests__/CreateAlertHeader.test.tsx

@@ -6,7 +6,9 @@ import { getCreateAlertLocalStateFromAlertDef } from 'container/CreateAlertV2/ut
 import * as useSafeNavigateHook from 'hooks/useSafeNavigate';
 import { AlertTypes } from 'types/api/alerts/alertTypes';
 
-import * as rulesHook from '../../../../api/generated/services/rules';
+import * as useCreateAlertRuleHook from '../../../../hooks/alerts/useCreateAlertRule';
+import * as useTestAlertRuleHook from '../../../../hooks/alerts/useTestAlertRule';
+import * as useUpdateAlertRuleHook from '../../../../hooks/alerts/useUpdateAlertRule';
 import { CreateAlertProvider } from '../../context';
 import CreateAlertHeader from '../CreateAlertHeader';
 
@@ -15,15 +17,15 @@ jest.spyOn(useSafeNavigateHook, 'useSafeNavigate').mockReturnValue({
 	safeNavigate: mockSafeNavigate,
 });
 
-jest.spyOn(rulesHook, 'useCreateRule').mockReturnValue({
+jest.spyOn(useCreateAlertRuleHook, 'useCreateAlertRule').mockReturnValue({
 	mutate: jest.fn(),
 	isLoading: false,
 } as any);
-jest.spyOn(rulesHook, 'useTestRule').mockReturnValue({
+jest.spyOn(useTestAlertRuleHook, 'useTestAlertRule').mockReturnValue({
 	mutate: jest.fn(),
 	isLoading: false,
 } as any);
-jest.spyOn(rulesHook, 'useUpdateRuleByID').mockReturnValue({
+jest.spyOn(useUpdateAlertRuleHook, 'useUpdateAlertRule').mockReturnValue({
 	mutate: jest.fn(),
 	isLoading: false,
 } as any);

frontend/src/container/CreateAlertV2/EvaluationSettings/__tests__/testUtils.ts

@@ -34,7 +34,6 @@ export const createMockAlertContextState = (
 	isUpdatingAlertRule: false,
 	updateAlertRule: jest.fn(),
 	isEditMode: false,
-	ruleId: '',
 	...overrides,
 });
 

frontend/src/container/CreateAlertV2/Footer/Footer.tsx

@@ -1,17 +1,9 @@
 import { useCallback, useMemo } from 'react';
 import { toast } from '@signozhq/sonner';
 import { Button, Tooltip, Typography } from 'antd';
-import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
-import type {
-	RenderErrorResponseDTO,
-	RuletypesPostableRuleDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { AxiosError } from 'axios';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import { Check, Loader, Send, X } from 'lucide-react';
-import { useErrorModal } from 'providers/ErrorModalProvider';
-import APIError from 'types/api/error';
 import { isModifierKeyPressed } from 'utils/app';
 
 import { useCreateAlertState } from '../context';
@@ -38,11 +30,9 @@ function Footer(): JSX.Element {
 		updateAlertRule,
 		isUpdatingAlertRule,
 		isEditMode,
-		ruleId,
 	} = useCreateAlertState();
 	const { currentQuery } = useQueryBuilder();
 	const { safeNavigate } = useSafeNavigate();
-	const { showErrorModal } = useErrorModal();
 
 	const handleDiscard = (e: React.MouseEvent): void => {
 		discardAlertRule();
@@ -81,27 +71,20 @@ function Footer(): JSX.Element {
 			notificationSettings,
 			query: currentQuery,
 		});
-		testAlertRule(
-			{ data: (payload as unknown) as RuletypesPostableRuleDTO },
-			{
-				onSuccess: (response) => {
-					if (response.data?.alertCount === 0) {
-						toast.error(
-							'No alerts found during the evaluation. This happens when rule condition is unsatisfied. You may adjust the rule threshold and retry.',
-						);
-						return;
-					}
-					toast.success('Test notification sent successfully');
-				},
-				onError: (error) => {
-					showErrorModal(
-						convertToApiError(
-							error as AxiosError<RenderErrorResponseDTO>,
-						) as APIError,
+		testAlertRule(payload, {
+			onSuccess: (response) => {
+				if (response.payload?.data?.alertCount === 0) {
+					toast.error(
+						'No alerts found during the evaluation. This happens when rule condition is unsatisfied. You may adjust the rule threshold and retry.',
 					);
-				},
+					return;
+				}
+				toast.success('Test notification sent successfully');
 			},
-		);
+			onError: (error) => {
+				toast.error(error.message);
+			},
+		});
 	}, [
 		alertType,
 		basicAlertState,
@@ -124,34 +107,25 @@ function Footer(): JSX.Element {
 			query: currentQuery,
 		});
 		if (isEditMode) {
-			updateAlertRule(
-				{
-					pathParams: { id: ruleId },
-					data: (payload as unknown) as RuletypesPostableRuleDTO,
+			updateAlertRule(payload, {
+				onSuccess: () => {
+					toast.success('Alert rule updated successfully');
+					safeNavigate('/alerts');
 				},
-				{
-					onSuccess: () => {
-						toast.success('Alert rule updated successfully');
-						safeNavigate('/alerts');
-					},
-					onError: (error) => {
-						toast.error(error.message);
-					},
+				onError: (error) => {
+					toast.error(error.message);
 				},
-			);
+			});
 		} else {
-			createAlertRule(
-				{ data: (payload as unknown) as RuletypesPostableRuleDTO },
-				{
-					onSuccess: () => {
-						toast.success('Alert rule created successfully');
-						safeNavigate('/alerts');
-					},
-					onError: (error) => {
-						toast.error(error.message);
-					},
+			createAlertRule(payload, {
+				onSuccess: () => {
+					toast.success('Alert rule created successfully');
+					safeNavigate('/alerts');
 				},
-			);
+				onError: (error) => {
+					toast.error(error.message);
+				},
+			});
 		}
 	}, [
 		alertType,
@@ -162,11 +136,9 @@ function Footer(): JSX.Element {
 		notificationSettings,
 		currentQuery,
 		isEditMode,
-		ruleId,
 		updateAlertRule,
 		createAlertRule,
 		safeNavigate,
-		showErrorModal,
 	]);
 
 	const disableButtons =

frontend/src/container/CreateAlertV2/Footer/__tests__/Footer.test.tsx

@@ -12,11 +12,6 @@ import Footer from '../Footer';
 jest.mock('hooks/queryBuilder/useQueryBuilder', () => ({
 	useQueryBuilder: jest.fn(),
 }));
-jest.mock('providers/ErrorModalProvider', () => ({
-	useErrorModal: (): { showErrorModal: jest.Mock } => ({
-		showErrorModal: jest.fn(),
-	}),
-}));
 
 jest.mock('hooks/useSafeNavigate', () => ({
 	useSafeNavigate: jest.fn(),

frontend/src/container/CreateAlertV2/context/index.tsx

@@ -10,13 +10,11 @@ import {
 	useState,
 } from 'react';
 import { useLocation } from 'react-router-dom';
-import {
-	useCreateRule,
-	useTestRule,
-	useUpdateRuleByID,
-} from 'api/generated/services/rules';
 import { QueryParams } from 'constants/query';
 import { AlertDetectionTypes } from 'container/FormAlertRules';
+import { useCreateAlertRule } from 'hooks/alerts/useCreateAlertRule';
+import { useTestAlertRule } from 'hooks/alerts/useTestAlertRule';
+import { useUpdateAlertRule } from 'hooks/alerts/useUpdateAlertRule';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { mapQueryDataFromApi } from 'lib/newQueryBuilder/queryBuilderMappers/mapQueryDataFromApi';
 import { AlertTypes } from 'types/api/alerts/alertTypes';
@@ -217,14 +215,17 @@ export function CreateAlertProvider(
 	const {
 		mutate: createAlertRule,
 		isLoading: isCreatingAlertRule,
-	} = useCreateRule();
+	} = useCreateAlertRule();
 
-	const { mutate: testAlertRule, isLoading: isTestingAlertRule } = useTestRule();
+	const {
+		mutate: testAlertRule,
+		isLoading: isTestingAlertRule,
+	} = useTestAlertRule();
 
 	const {
 		mutate: updateAlertRule,
 		isLoading: isUpdatingAlertRule,
-	} = useUpdateRuleByID();
+	} = useUpdateAlertRule(ruleId || '');
 
 	const contextValue: ICreateAlertContextProps = useMemo(
 		() => ({
@@ -248,7 +249,6 @@ export function CreateAlertProvider(
 			updateAlertRule,
 			isUpdatingAlertRule,
 			isEditMode: isEditMode || false,
-			ruleId: ruleId || '',
 		}),
 		[
 			createAlertState,
@@ -267,7 +267,6 @@ export function CreateAlertProvider(
 			updateAlertRule,
 			isUpdatingAlertRule,
 			isEditMode,
-			ruleId,
 		],
 	);
 

frontend/src/container/CreateAlertV2/context/types.ts

@@ -1,15 +1,12 @@
 import { Dispatch } from 'react';
 import { UseMutateFunction } from 'react-query';
-import type {
-	CreateRule200,
-	RenderErrorResponseDTO,
-	RuletypesPostableRuleDTO,
-	TestRule200,
-	UpdateRuleByIDPathParameters,
-} from 'api/generated/services/sigNoz.schemas';
-import type { BodyType, ErrorType } from 'api/generatedAPIInstance';
+import { CreateAlertRuleResponse } from 'api/alerts/createAlertRule';
+import { TestAlertRuleResponse } from 'api/alerts/testAlertRule';
+import { UpdateAlertRuleResponse } from 'api/alerts/updateAlertRule';
 import { Dayjs } from 'dayjs';
+import { ErrorResponse, SuccessResponse } from 'types/api';
 import { AlertTypes } from 'types/api/alerts/alertTypes';
+import { PostableAlertRuleV2 } from 'types/api/alerts/alertTypesV2';
 import { Labels } from 'types/api/alerts/def';
 
 export interface ICreateAlertContextProps {
@@ -27,33 +24,27 @@ export interface ICreateAlertContextProps {
 	setNotificationSettings: Dispatch<NotificationSettingsAction>;
 	isCreatingAlertRule: boolean;
 	createAlertRule: UseMutateFunction<
-		CreateRule200,
-		ErrorType<unknown>,
-		{ data: BodyType<RuletypesPostableRuleDTO> },
+		SuccessResponse<CreateAlertRuleResponse, unknown> | ErrorResponse,
+		Error,
+		PostableAlertRuleV2,
 		unknown
 	>;
 	isTestingAlertRule: boolean;
 	testAlertRule: UseMutateFunction<
-		TestRule200,
-		ErrorType<unknown>,
-		{ data: BodyType<RuletypesPostableRuleDTO> },
+		SuccessResponse<TestAlertRuleResponse, unknown> | ErrorResponse,
+		Error,
+		PostableAlertRuleV2,
 		unknown
 	>;
 	discardAlertRule: () => void;
 	isUpdatingAlertRule: boolean;
 	updateAlertRule: UseMutateFunction<
-		Awaited<
-			ReturnType<typeof import('api/generated/services/rules').updateRuleByID>
-		>,
-		ErrorType<RenderErrorResponseDTO>,
-		{
-			pathParams: UpdateRuleByIDPathParameters;
-			data: BodyType<RuletypesPostableRuleDTO>;
-		},
+		SuccessResponse<UpdateAlertRuleResponse, unknown> | ErrorResponse,
+		Error,
+		PostableAlertRuleV2,
 		unknown
 	>;
 	isEditMode: boolean;
-	ruleId: string;
 }
 
 export interface ICreateAlertProviderProps {

frontend/src/container/CustomDomainSettings/CustomDomainSettings.tsx

@@ -21,6 +21,7 @@ import { useGetHosts, usePutHost } from 'api/generated/services/zeus';
 import { AxiosError } from 'axios';
 import { useAppContext } from 'providers/App/App';
 import { useTimezone } from 'providers/Timezone';
+import { openExternalLink } from 'utils/navigation';
 
 import CustomDomainEditModal from './CustomDomainEditModal';
 
@@ -48,7 +49,7 @@ function DomainUpdateToast({
 					className="custom-domain-toast-visit-btn"
 					suffixIcon={<ExternalLink size={12} />}
 					onClick={(): void => {
-						window.open(url, '_blank', 'noopener,noreferrer');
+						openExternalLink(url);
 					}}
 				>
 					Visit new URL

frontend/src/container/DashboardContainer/DashboardSettings/PublicDashboard/index.tsx

@@ -16,6 +16,7 @@ import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { PublicDashboardMetaProps } from 'types/api/dashboard/public/getMeta';
 import APIError from 'types/api/error';
 import { USER_ROLES } from 'types/roles';
+import { openInNewTab } from 'utils/navigation';
 
 import './PublicDashboard.styles.scss';
 
@@ -294,7 +295,7 @@ function PublicDashboardSetting(): JSX.Element {
 								icon={<ExternalLink size={12} />}
 								onClick={(): void => {
 									if (publicDashboardURL) {
-										window.open(publicDashboardURL, '_blank');
+										openInNewTab(publicDashboardURL);
 									}
 								}}
 							/>

frontend/src/container/FormAlertRules/BasicInfo.tsx

@@ -15,6 +15,7 @@ import { AlertDef, Labels } from 'types/api/alerts/def';
 import { Channels } from 'types/api/channels/getAll';
 import APIError from 'types/api/error';
 import { requireErrorMessage } from 'utils/form/requireErrorMessage';
+import { openInNewTab } from 'utils/navigation';
 import { popupContainer } from 'utils/selectPopupContainer';
 
 import ChannelSelect from './ChannelSelect';
@@ -87,7 +88,7 @@ function BasicInfo({
 			dataSource: ALERTS_DATA_SOURCE_MAP[alertDef?.alertType as AlertTypes],
 			ruleId: isNewRule ? 0 : alertDef?.id,
 		});
-		window.open(ROUTES.CHANNELS_NEW, '_blank');
+		openInNewTab(ROUTES.CHANNELS_NEW);
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, []);
 	const hasLoggedEvent = useRef(false);

frontend/src/container/FormAlertRules/index.tsx

@@ -6,18 +6,9 @@ import { useSelector } from 'react-redux';
 import { useLocation } from 'react-router-dom';
 import { ExclamationCircleOutlined, SaveOutlined } from '@ant-design/icons';
 import { Button, FormInstance, Modal, SelectProps, Typography } from 'antd';
+import saveAlertApi from 'api/alerts/save';
+import testAlertApi from 'api/alerts/testAlert';
 import logEvent from 'api/common/logEvent';
-import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
-import {
-	createRule,
-	testRule,
-	updateRuleByID,
-} from 'api/generated/services/rules';
-import type {
-	RenderErrorResponseDTO,
-	RuletypesPostableRuleDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { AxiosError } from 'axios';
 import { getInvolvedQueriesInTraceOperator } from 'components/QueryBuilderV2/QueryV2/TraceOperator/utils/utils';
 import YAxisUnitSelector from 'components/YAxisUnitSelector';
 import { YAxisSource } from 'components/YAxisUnitSelector/types';
@@ -41,7 +32,6 @@ import { isEmpty, isEqual } from 'lodash-es';
 import { BellDot, ExternalLink } from 'lucide-react';
 import Tabs2 from 'periscope/components/Tabs2';
 import { useAppContext } from 'providers/App/App';
-import { useErrorModal } from 'providers/ErrorModalProvider';
 import { AppState } from 'store/reducers';
 import { AlertTypes } from 'types/api/alerts/alertTypes';
 import {
@@ -49,7 +39,6 @@ import {
 	defaultEvalWindow,
 	defaultMatchType,
 } from 'types/api/alerts/def';
-import APIError from 'types/api/error';
 import { IBuilderQuery, Query } from 'types/api/queryBuilder/queryBuilderData';
 import { QueryFunction } from 'types/api/v5/queryRange';
 import { EQueryType } from 'types/common/dashboard';
@@ -57,6 +46,7 @@ import { DataSource } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
 import { isModifierKeyPressed } from 'utils/app';
 import { compositeQueryToQueryEnvelope } from 'utils/compositeQueryToQueryEnvelope';
+import { openExternalLink } from 'utils/navigation';
 
 import BasicInfo from './BasicInfo';
 import ChartPreview from './ChartPreview';
@@ -379,7 +369,6 @@ function FormAlertRules({
 		redirectWithQueryBuilderData(query);
 	};
 	const { notifications } = useNotifications();
-	const { showErrorModal } = useErrorModal();
 
 	const validatePromParams = useCallback((): boolean => {
 		let retval = true;
@@ -545,47 +534,59 @@ function FormAlertRules({
 		};
 
 		try {
-			if (ruleId && !isEmpty(ruleId)) {
-				await updateRuleByID(
-					{ id: ruleId },
-					(postableAlert as unknown) as RuletypesPostableRuleDTO,
-				);
+			const apiReq =
+				ruleId && !isEmpty(ruleId)
+					? { data: postableAlert, id: ruleId }
+					: { data: postableAlert };
+
+			const response = await saveAlertApi(apiReq);
+
+			if (response.statusCode === 200) {
+				logData = {
+					status: 'success',
+					statusMessage: isNewRule ? t('rule_created') : t('rule_edited'),
+				};
+
+				notifications.success({
+					message: 'Success',
+					description: logData.statusMessage,
+				});
+
+				// invalidate rule in cache
+				ruleCache.invalidateQueries([
+					REACT_QUERY_KEY.ALERT_RULE_DETAILS,
+					`${ruleId}`,
+				]);
+
+				// eslint-disable-next-line sonarjs/no-identical-functions
+				setTimeout(() => {
+					urlQuery.delete(QueryParams.compositeQuery);
+					urlQuery.delete(QueryParams.panelTypes);
+					urlQuery.delete(QueryParams.ruleId);
+					urlQuery.delete(QueryParams.relativeTime);
+					safeNavigate(`${ROUTES.LIST_ALL_ALERT}?${urlQuery.toString()}`);
+				}, 2000);
 			} else {
-				await createRule((postableAlert as unknown) as RuletypesPostableRuleDTO);
+				logData = {
+					status: 'error',
+					statusMessage: response.error || t('unexpected_error'),
+				};
+
+				notifications.error({
+					message: 'Error',
+					description: logData.statusMessage,
+				});
 			}
-
-			logData = {
-				status: 'success',
-				statusMessage: isNewRule ? t('rule_created') : t('rule_edited'),
-			};
-
-			notifications.success({
-				message: 'Success',
-				description: logData.statusMessage,
-			});
-
-			// invalidate rule in cache
-			ruleCache.invalidateQueries([
-				REACT_QUERY_KEY.ALERT_RULE_DETAILS,
-				`${ruleId}`,
-			]);
-
-			// eslint-disable-next-line sonarjs/no-identical-functions
-			setTimeout(() => {
-				urlQuery.delete(QueryParams.compositeQuery);
-				urlQuery.delete(QueryParams.panelTypes);
-				urlQuery.delete(QueryParams.ruleId);
-				urlQuery.delete(QueryParams.relativeTime);
-				safeNavigate(`${ROUTES.LIST_ALL_ALERT}?${urlQuery.toString()}`);
-			}, 2000);
 		} catch (e) {
-			const apiError = convertToApiError(e as AxiosError<RenderErrorResponseDTO>);
 			logData = {
 				status: 'error',
-				statusMessage: apiError?.getErrorMessage() || t('unexpected_error'),
+				statusMessage: t('unexpected_error'),
 			};
 
-			showErrorModal(apiError as APIError);
+			notifications.error({
+				message: 'Error',
+				description: logData.statusMessage,
+			});
 		}
 
 		setLoading(false);
@@ -641,30 +642,39 @@ function FormAlertRules({
 		let statusResponse = { status: 'failed', message: '' };
 		setLoading(true);
 		try {
-			const response = await testRule(
-				(postableAlert as unknown) as RuletypesPostableRuleDTO,
-			);
+			const response = await testAlertApi({ data: postableAlert });
 
-			if (response.data?.alertCount === 0) {
+			if (response.statusCode === 200) {
+				const { payload } = response;
+				if (payload?.alertCount === 0) {
+					notifications.error({
+						message: 'Error',
+						description: t('no_alerts_found'),
+					});
+					statusResponse = { status: 'failed', message: t('no_alerts_found') };
+				} else {
+					notifications.success({
+						message: 'Success',
+						description: t('rule_test_fired'),
+					});
+					statusResponse = { status: 'success', message: t('rule_test_fired') };
+				}
+			} else {
 				notifications.error({
 					message: 'Error',
-					description: t('no_alerts_found'),
+					description: response.error || t('unexpected_error'),
 				});
-				statusResponse = { status: 'failed', message: t('no_alerts_found') };
-			} else {
-				notifications.success({
-					message: 'Success',
-					description: t('rule_test_fired'),
-				});
-				statusResponse = { status: 'success', message: t('rule_test_fired') };
+				statusResponse = {
+					status: 'failed',
+					message: response.error || t('unexpected_error'),
+				};
 			}
 		} catch (e) {
-			const apiError = convertToApiError(e as AxiosError<RenderErrorResponseDTO>);
-			statusResponse = {
-				status: 'failed',
-				message: apiError?.getErrorMessage() || t('unexpected_error'),
-			};
-			showErrorModal(apiError as APIError);
+			notifications.error({
+				message: 'Error',
+				description: t('unexpected_error'),
+			});
+			statusResponse = { status: 'failed', message: t('unexpected_error') };
 		}
 		setLoading(false);
 		logEvent('Alert: Test notification', {
@@ -762,7 +772,7 @@ function FormAlertRules({
 				queryType: currentQuery.queryType,
 				link: url,
 			});
-			window.open(url, '_blank');
+			openExternalLink(url);
 		}
 	}
 

frontend/src/container/GeneralSettings/GeneralSettings.tsx

@@ -38,7 +38,6 @@ import {
 } from 'types/api/settings/getRetention';
 import { USER_ROLES } from 'types/roles';
 
-import LicenseRowDismissibleCallout from './LicenseKeyRow/LicenseRowDismissibleCallout/LicenseRowDismissibleCallout';
 import Retention from './Retention';
 import StatusMessage from './StatusMessage';
 import { ActionItemsContainer, ErrorText, ErrorTextContainer } from './styles';
@@ -684,12 +683,7 @@ function GeneralSettings({
 					{showCustomDomainSettings && activeLicense?.key && (
 						<div className="custom-domain-card-divider" />
 					)}
-					{activeLicense?.key && (
-						<>
-							<LicenseKeyRow />
-							<LicenseRowDismissibleCallout />
-						</>
-					)}
+					{activeLicense?.key && <LicenseKeyRow />}
 				</div>
 			)}
 

frontend/src/container/GeneralSettings/LicenseKeyRow/LicenseRowDismissibleCallout/LicenseRowDismissible.styles.scss

@@ -1,31 +0,0 @@
-.license-key-callout {
-	margin: var(--spacing-4) var(--spacing-6);
-	width: auto;
-
-	.license-key-callout__description {
-		display: flex;
-		align-items: baseline;
-		gap: var(--spacing-2);
-		min-width: 0;
-		flex-wrap: wrap;
-		font-size: 13px;
-	}
-
-	.license-key-callout__link {
-		display: inline-flex;
-		align-items: center;
-		padding: var(--spacing-1) var(--spacing-3);
-		border-radius: 2px;
-		background: var(--callout-primary-background);
-		color: var(--callout-primary-description);
-		font-family: 'SF Mono', 'Fira Code', 'Fira Mono', monospace;
-		font-size: var(--paragraph-base-400-font-size);
-		text-decoration: none;
-
-		&:hover {
-			background: var(--callout-primary-border);
-			color: var(--callout-primary-icon);
-			text-decoration: none;
-		}
-	}
-}

frontend/src/container/GeneralSettings/LicenseKeyRow/LicenseRowDismissibleCallout/LicenseRowDismissibleCallout.tsx

@@ -1,83 +0,0 @@
-import { useState } from 'react';
-import { Link } from 'react-router-dom';
-import { Callout } from '@signozhq/callout';
-import getLocalStorageApi from 'api/browser/localstorage/get';
-import setLocalStorageApi from 'api/browser/localstorage/set';
-import { FeatureKeys } from 'constants/features';
-import { LOCALSTORAGE } from 'constants/localStorage';
-import ROUTES from 'constants/routes';
-import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
-import { useAppContext } from 'providers/App/App';
-import { USER_ROLES } from 'types/roles';
-
-import './LicenseRowDismissible.styles.scss';
-
-function LicenseRowDismissibleCallout(): JSX.Element | null {
-	const [isCalloutDismissed, setIsCalloutDismissed] = useState<boolean>(
-		() =>
-			getLocalStorageApi(LOCALSTORAGE.LICENSE_KEY_CALLOUT_DISMISSED) === 'true',
-	);
-
-	const { user, featureFlags } = useAppContext();
-	const { isCloudUser } = useGetTenantLicense();
-
-	const isAdmin = user.role === USER_ROLES.ADMIN;
-	const isEditor = user.role === USER_ROLES.EDITOR;
-
-	const isGatewayEnabled =
-		featureFlags?.find((feature) => feature.name === FeatureKeys.GATEWAY)
-			?.active || false;
-
-	const hasServiceAccountsAccess = isAdmin;
-
-	const hasIngestionAccess =
-		(isCloudUser && !isGatewayEnabled) ||
-		(isGatewayEnabled && (isAdmin || isEditor));
-
-	const handleDismissCallout = (): void => {
-		setLocalStorageApi(LOCALSTORAGE.LICENSE_KEY_CALLOUT_DISMISSED, 'true');
-		setIsCalloutDismissed(true);
-	};
-
-	return !isCalloutDismissed ? (
-		<Callout
-			type="info"
-			size="small"
-			showIcon
-			dismissable
-			onClose={handleDismissCallout}
-			className="license-key-callout"
-			description={
-				<div className="license-key-callout__description">
-					This is <strong>NOT</strong> your ingestion or Service account key.
-					{(hasServiceAccountsAccess || hasIngestionAccess) && (
-						<>
-							{' '}
-							Find your{' '}
-							{hasServiceAccountsAccess && (
-								<Link
-									to={ROUTES.SERVICE_ACCOUNTS_SETTINGS}
-									className="license-key-callout__link"
-								>
-									Service account here
-								</Link>
-							)}
-							{hasServiceAccountsAccess && hasIngestionAccess && ' and '}
-							{hasIngestionAccess && (
-								<Link
-									to={ROUTES.INGESTION_SETTINGS}
-									className="license-key-callout__link"
-								>
-									Ingestion key here
-								</Link>
-							)}
-							.
-						</>
-					)}
-				</div>
-			}
-		/>
-	) : null;
-}
-
-export default LicenseRowDismissibleCallout;

frontend/src/container/GeneralSettings/LicenseKeyRow/LicenseRowDismissibleCallout/__tests__/LicenseRowDismissibleCallout.test.tsx

@@ -1,229 +0,0 @@
-import { FeatureKeys } from 'constants/features';
-import { LOCALSTORAGE } from 'constants/localStorage';
-import ROUTES from 'constants/routes';
-import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
-import { render, screen, userEvent } from 'tests/test-utils';
-import { USER_ROLES } from 'types/roles';
-
-import LicenseRowDismissibleCallout from '../LicenseRowDismissibleCallout';
-
-const getDescription = (): HTMLElement =>
-	screen.getByText(
-		(_, el) =>
-			el?.classList?.contains('license-key-callout__description') ?? false,
-	);
-
-const queryDescription = (): HTMLElement | null =>
-	screen.queryByText(
-		(_, el) =>
-			el?.classList?.contains('license-key-callout__description') ?? false,
-	);
-
-jest.mock('hooks/useGetTenantLicense', () => ({
-	useGetTenantLicense: jest.fn(),
-}));
-
-const mockLicense = (isCloudUser: boolean): void => {
-	(useGetTenantLicense as jest.Mock).mockReturnValue({
-		isCloudUser,
-		isEnterpriseSelfHostedUser: !isCloudUser,
-		isCommunityUser: false,
-		isCommunityEnterpriseUser: false,
-	});
-};
-
-const renderCallout = (
-	role: string,
-	isCloudUser: boolean,
-	gatewayActive: boolean,
-): void => {
-	mockLicense(isCloudUser);
-	render(
-		<LicenseRowDismissibleCallout />,
-		{},
-		{
-			role,
-			appContextOverrides: {
-				featureFlags: [
-					{
-						name: FeatureKeys.GATEWAY,
-						active: gatewayActive,
-						usage: 0,
-						usage_limit: -1,
-						route: '',
-					},
-				],
-			},
-		},
-	);
-};
-
-describe('LicenseRowDismissibleCallout', () => {
-	beforeEach(() => {
-		localStorage.clear();
-		jest.clearAllMocks();
-	});
-
-	describe('callout content per access level', () => {
-		it.each([
-			{
-				scenario: 'viewer, non-cloud, gateway off — base text only, no links',
-				role: USER_ROLES.VIEWER,
-				isCloudUser: false,
-				gatewayActive: false,
-				serviceAccountLink: false,
-				ingestionLink: false,
-				expectedText: 'This is NOT your ingestion or Service account key.',
-			},
-			{
-				scenario: 'admin, non-cloud, gateway off — service accounts link only',
-				role: USER_ROLES.ADMIN,
-				isCloudUser: false,
-				gatewayActive: false,
-				serviceAccountLink: true,
-				ingestionLink: false,
-				expectedText:
-					'This is NOT your ingestion or Service account key. Find your Service account here.',
-			},
-			{
-				scenario: 'viewer, cloud, gateway off — ingestion link only',
-				role: USER_ROLES.VIEWER,
-				isCloudUser: true,
-				gatewayActive: false,
-				serviceAccountLink: false,
-				ingestionLink: true,
-				expectedText:
-					'This is NOT your ingestion or Service account key. Find your Ingestion key here.',
-			},
-			{
-				scenario: 'admin, cloud, gateway off — both links',
-				role: USER_ROLES.ADMIN,
-				isCloudUser: true,
-				gatewayActive: false,
-				serviceAccountLink: true,
-				ingestionLink: true,
-				expectedText:
-					'This is NOT your ingestion or Service account key. Find your Service account here and Ingestion key here.',
-			},
-			{
-				scenario: 'admin, non-cloud, gateway on — both links',
-				role: USER_ROLES.ADMIN,
-				isCloudUser: false,
-				gatewayActive: true,
-				serviceAccountLink: true,
-				ingestionLink: true,
-				expectedText:
-					'This is NOT your ingestion or Service account key. Find your Service account here and Ingestion key here.',
-			},
-			{
-				scenario: 'editor, non-cloud, gateway on — ingestion link only',
-				role: USER_ROLES.EDITOR,
-				isCloudUser: false,
-				gatewayActive: true,
-				serviceAccountLink: false,
-				ingestionLink: true,
-				expectedText:
-					'This is NOT your ingestion or Service account key. Find your Ingestion key here.',
-			},
-			{
-				scenario: 'editor, cloud, gateway off — ingestion link only',
-				role: USER_ROLES.EDITOR,
-				isCloudUser: true,
-				gatewayActive: false,
-				serviceAccountLink: false,
-				ingestionLink: true,
-				expectedText:
-					'This is NOT your ingestion or Service account key. Find your Ingestion key here.',
-			},
-		])(
-			'$scenario',
-			({
-				role,
-				isCloudUser,
-				gatewayActive,
-				serviceAccountLink,
-				ingestionLink,
-				expectedText,
-			}) => {
-				renderCallout(role, isCloudUser, gatewayActive);
-
-				const description = getDescription();
-				expect(description).toBeInTheDocument();
-				expect(description).toHaveTextContent(expectedText);
-
-				if (serviceAccountLink) {
-					expect(
-						screen.getByRole('link', { name: /Service account here/ }),
-					).toBeInTheDocument();
-				} else {
-					expect(
-						screen.queryByRole('link', { name: /Service account here/ }),
-					).not.toBeInTheDocument();
-				}
-
-				if (ingestionLink) {
-					expect(
-						screen.getByRole('link', { name: /Ingestion key here/ }),
-					).toBeInTheDocument();
-				} else {
-					expect(
-						screen.queryByRole('link', { name: /Ingestion key here/ }),
-					).not.toBeInTheDocument();
-				}
-			},
-		);
-	});
-
-	describe('Link routing', () => {
-		it('should link to service accounts settings', () => {
-			renderCallout(USER_ROLES.ADMIN, false, false);
-
-			const link = screen.getByRole('link', {
-				name: /Service account here/,
-			}) as HTMLAnchorElement;
-
-			expect(link.getAttribute('href')).toBe(ROUTES.SERVICE_ACCOUNTS_SETTINGS);
-		});
-
-		it('should link to ingestion settings', () => {
-			renderCallout(USER_ROLES.VIEWER, true, false);
-
-			const link = screen.getByRole('link', {
-				name: /Ingestion key here/,
-			}) as HTMLAnchorElement;
-
-			expect(link.getAttribute('href')).toBe(ROUTES.INGESTION_SETTINGS);
-		});
-	});
-
-	describe('Dismissal functionality', () => {
-		it('should hide callout when dismiss button is clicked', async () => {
-			const user = userEvent.setup();
-			renderCallout(USER_ROLES.ADMIN, false, false);
-
-			expect(getDescription()).toBeInTheDocument();
-
-			await user.click(screen.getByRole('button'));
-
-			expect(queryDescription()).not.toBeInTheDocument();
-		});
-
-		it('should persist dismissal in localStorage', async () => {
-			const user = userEvent.setup();
-			renderCallout(USER_ROLES.ADMIN, false, false);
-
-			await user.click(screen.getByRole('button'));
-
-			expect(
-				localStorage.getItem(LOCALSTORAGE.LICENSE_KEY_CALLOUT_DISMISSED),
-			).toBe('true');
-		});
-
-		it('should not render when localStorage dismissal is set', () => {
-			localStorage.setItem(LOCALSTORAGE.LICENSE_KEY_CALLOUT_DISMISSED, 'true');
-			renderCallout(USER_ROLES.ADMIN, false, false);
-
-			expect(queryDescription()).not.toBeInTheDocument();
-		});
-	});
-});

frontend/src/container/Home/AlertRules/AlertRules.tsx

@@ -1,9 +1,9 @@
 import { useEffect, useState } from 'react';
+import { useQuery } from 'react-query';
 import { Link, useLocation } from 'react-router-dom';
 import { Button, Skeleton, Tag } from 'antd';
+import getAll from 'api/alerts/getAll';
 import logEvent from 'api/common/logEvent';
-import { useListRules } from 'api/generated/services/rules';
-import type { RuletypesGettableRuleDTO } from 'api/generated/services/sigNoz.schemas';
 import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
 import history from 'lib/history';
@@ -11,8 +11,9 @@ import { mapQueryDataFromApi } from 'lib/newQueryBuilder/queryBuilderMappers/map
 import { ArrowRight, ArrowUpRight, Plus } from 'lucide-react';
 import Card from 'periscope/components/Card/Card';
 import { useAppContext } from 'providers/App/App';
-import type { ICompositeMetricQuery } from 'types/api/alerts/compositeQuery';
+import { GettableAlert } from 'types/api/alerts/get';
 import { USER_ROLES } from 'types/roles';
+import { openExternalLink } from 'utils/navigation';
 
 import beaconUrl from '@/assets/Icons/beacon.svg';
 
@@ -28,23 +29,22 @@ export default function AlertRules({
 	const { user } = useAppContext();
 	const [rulesExist, setRulesExist] = useState(false);
 
-	const [sortedAlertRules, setSortedAlertRules] = useState<
-		RuletypesGettableRuleDTO[]
-	>([]);
+	const [sortedAlertRules, setSortedAlertRules] = useState<GettableAlert[]>([]);
 
 	const location = useLocation();
 	const params = new URLSearchParams(location.search);
 
 	// Fetch Alerts
-	const { data: alerts, isError, isLoading } = useListRules({
-		query: { cacheTime: 0 },
+	const { data: alerts, isError, isLoading } = useQuery('allAlerts', {
+		queryFn: getAll,
+		cacheTime: 0,
 	});
 
 	useEffect(() => {
-		const rules = alerts?.data?.rules ?? [];
+		const rules = alerts?.payload || [];
 		setRulesExist(rules.length > 0);
 
-		const sortedRules = [...rules].sort((a, b) => {
+		const sortedRules = rules.sort((a, b) => {
 			// First, prioritize firing alerts
 			if (a.state === 'firing' && b.state !== 'firing') {
 				return -1;
@@ -54,8 +54,8 @@ export default function AlertRules({
 			}
 
 			// Then sort by updateAt timestamp
-			const aUpdateAt = a.updateAt ? new Date(a.updateAt).getTime() : 0;
-			const bUpdateAt = b.updateAt ? new Date(b.updateAt).getTime() : 0;
+			const aUpdateAt = new Date(a.updateAt).getTime();
+			const bUpdateAt = new Date(b.updateAt).getTime();
 			return bUpdateAt - aUpdateAt;
 		});
 
@@ -104,11 +104,7 @@ export default function AlertRules({
 									source: 'Alert Rules',
 								});
 
-								window.open(
-									'https://signoz.io/docs/alerts/',
-									'_blank',
-									'noreferrer noopener',
-								);
+								openExternalLink('https://signoz.io/docs/alerts/');
 							}}
 						>
 							Learn more <ArrowUpRight size={12} />
@@ -119,27 +115,22 @@ export default function AlertRules({
 		</div>
 	);
 
-	const onEditHandler = (record: RuletypesGettableRuleDTO) => (): void => {
+	const onEditHandler = (record: GettableAlert) => (): void => {
 		logEvent('Homepage: Alert clicked', {
 			ruleId: record.id,
 			ruleName: record.alert,
 			ruleState: record.state,
 		});
 
-		const compositeQuery = mapQueryDataFromApi(
-			(record.condition?.compositeQuery as unknown) as ICompositeMetricQuery,
-		);
+		const compositeQuery = mapQueryDataFromApi(record.condition.compositeQuery);
 		params.set(
 			QueryParams.compositeQuery,
 			encodeURIComponent(JSON.stringify(compositeQuery)),
 		);
 
-		const panelType = record.condition?.compositeQuery?.panelType;
-		if (panelType) {
-			params.set(QueryParams.panelTypes, panelType);
-		}
+		params.set(QueryParams.panelTypes, record.condition.compositeQuery.panelType);
 
-		params.set(QueryParams.ruleId, record.id ?? '');
+		params.set(QueryParams.ruleId, record.id.toString());
 
 		history.push(`${ROUTES.ALERT_OVERVIEW}?${params.toString()}`);
 	};
@@ -162,7 +153,7 @@ export default function AlertRules({
 					>
 						<div className="alert-rule-item-name-container home-data-item-name-container">
 							<img
-								src={getItemIcon(rule.id ?? '')}
+								src={getItemIcon(rule.id)}
 								alt="alert-rules"
 								className="alert-rules-img"
 							/>

frontend/src/container/Home/Dashboards/Dashboards.tsx

@@ -10,6 +10,7 @@ import Card from 'periscope/components/Card/Card';
 import { useAppContext } from 'providers/App/App';
 import { Dashboard } from 'types/api/dashboard/getAll';
 import { USER_ROLES } from 'types/roles';
+import { openExternalLink, openInNewTab } from 'utils/navigation';
 
 import dialsUrl from '@/assets/Icons/dials.svg';
 
@@ -87,10 +88,7 @@ export default function Dashboards({
 								logEvent('Homepage: Learn more clicked', {
 									source: 'Dashboards',
 								});
-								window.open(
-									'https://signoz.io/docs/userguide/manage-dashboards/',
-									'_blank',
-								);
+								openExternalLink('https://signoz.io/docs/userguide/manage-dashboards/');
 							}}
 						>
 							Learn more <ArrowUpRight size={12} />
@@ -114,7 +112,7 @@ export default function Dashboards({
 							dashboardName: dashboard.data.title,
 						});
 						if (event.metaKey || event.ctrlKey) {
-							window.open(getLink(), '_blank');
+							openInNewTab(getLink());
 						} else {
 							safeNavigate(getLink());
 						}

frontend/src/container/Home/DataSourceInfo/DataSourceInfo.tsx

@@ -9,6 +9,7 @@ import { Link2 } from 'lucide-react';
 import Card from 'periscope/components/Card/Card';
 import { useAppContext } from 'providers/App/App';
 import { LicensePlatform } from 'types/api/licensesV3/getActive';
+import { openExternalLink } from 'utils/navigation';
 
 import containerPlusUrl from '@/assets/Icons/container-plus.svg';
 import helloWaveUrl from '@/assets/Icons/hello-wave.svg';
@@ -51,7 +52,7 @@ function DataSourceInfo({
 		if (activeLicense && activeLicense.platform === LicensePlatform.CLOUD) {
 			history.push(ROUTES.GET_STARTED_WITH_CLOUD);
 		} else {
-			window?.open(DOCS_LINKS.ADD_DATA_SOURCE, '_blank', 'noopener noreferrer');
+			openExternalLink(DOCS_LINKS.ADD_DATA_SOURCE);
 		}
 	};
 

frontend/src/container/Home/HomeChecklist/HomeChecklist.tsx

@@ -8,6 +8,7 @@ import { ArrowRight, ArrowRightToLine, BookOpenText } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
 import { LicensePlatform } from 'types/api/licensesV3/getActive';
 import { USER_ROLES } from 'types/roles';
+import { openExternalLink } from 'utils/navigation';
 
 import './HomeChecklist.styles.scss';
 
@@ -99,11 +100,7 @@ function HomeChecklist({
 														) {
 															history.push(item.toRoute || '');
 														} else {
-															window?.open(
-																item.docsLink || '',
-																'_blank',
-																'noopener noreferrer',
-															);
+															openExternalLink(item.docsLink || '');
 														}
 													}}
 												>
@@ -119,7 +116,7 @@ function HomeChecklist({
 																step: item.id,
 															});
 
-															window?.open(item.docsLink, '_blank', 'noopener noreferrer');
+															openExternalLink(item.docsLink || '');
 														}}
 													>
 														<BookOpenText size={16} />

frontend/src/container/Home/SavedViews/SavedViews.tsx

@@ -19,12 +19,13 @@ import { useAppContext } from 'providers/App/App';
 import { ViewProps } from 'types/api/saveViews/types';
 import { DataSource } from 'types/common/queryBuilder';
 import { USER_ROLES } from 'types/roles';
+import { openExternalLink } from 'utils/navigation';
 
+import circusTentUrl from '@/assets/Icons/circus-tent.svg';
+import eightBallUrl from '@/assets/Icons/eight-ball.svg';
 import floppyDiscUrl from '@/assets/Icons/floppy-disc.svg';
 import logsUrl from '@/assets/Icons/logs.svg';
 
-import { getItemIcon } from '../constants';
-
 export default function SavedViews({
 	onUpdateChecklistDoneItem,
 	loadingUserPreferences,
@@ -196,11 +197,7 @@ export default function SavedViews({
 									entity: selectedEntity,
 								});
 
-								window.open(
-									'https://signoz.io/docs/product-features/saved-view/',
-									'_blank',
-									'noopener noreferrer',
-								);
+								openExternalLink('https://signoz.io/docs/product-features/saved-view/');
 							}}
 						>
 							Learn more <ArrowUpRight size={12} />
@@ -229,7 +226,7 @@ export default function SavedViews({
 					>
 						<div className="saved-view-item-name-container home-data-item-name-container">
 							<img
-								src={getItemIcon(String(view.id))}
+								src={view.id % 2 === 0 ? eightBallUrl : circusTentUrl}
 								alt="alert-rules"
 								className="alert-rules-img"
 							/>

frontend/src/container/Home/Services/ServiceMetrics.tsx

@@ -31,6 +31,7 @@ import { GlobalReducer } from 'types/reducer/globalTime';
 import { Tags } from 'types/reducer/trace';
 import { USER_ROLES } from 'types/roles';
 import { isModifierKeyPressed } from 'utils/app';
+import { openExternalLink } from 'utils/navigation';
 
 import triangleRulerUrl from '@/assets/Icons/triangle-ruler.svg';
 
@@ -79,11 +80,7 @@ const EmptyState = memo(
 								) {
 									history.push(ROUTES.GET_STARTED_WITH_CLOUD);
 								} else {
-									window?.open(
-										DOCS_LINKS.ADD_DATA_SOURCE,
-										'_blank',
-										'noopener noreferrer',
-									);
+									openExternalLink(DOCS_LINKS.ADD_DATA_SOURCE);
 								}
 							}}
 						>
@@ -97,10 +94,7 @@ const EmptyState = memo(
 								logEvent('Homepage: Learn more clicked', {
 									source: 'Service Metrics',
 								});
-								window.open(
-									'https://signoz.io/docs/instrumentation/overview/',
-									'_blank',
-								);
+								openExternalLink('https://signoz.io/docs/instrumentation/overview/');
 							}}
 						>
 							Learn more <ArrowUpRight size={12} />

frontend/src/container/Home/Services/ServiceTraces.tsx

@@ -17,6 +17,7 @@ import { ServicesList } from 'types/api/metrics/getService';
 import { GlobalReducer } from 'types/reducer/globalTime';
 import { USER_ROLES } from 'types/roles';
 import { isModifierKeyPressed } from 'utils/app';
+import { openExternalLink } from 'utils/navigation';
 
 import triangleRulerUrl from '@/assets/Icons/triangle-ruler.svg';
 
@@ -133,11 +134,7 @@ export default function ServiceTraces({
 									) {
 										history.push(ROUTES.GET_STARTED_WITH_CLOUD);
 									} else {
-										window?.open(
-											DOCS_LINKS.ADD_DATA_SOURCE,
-											'_blank',
-											'noopener noreferrer',
-										);
+										openExternalLink(DOCS_LINKS.ADD_DATA_SOURCE);
 									}
 								}}
 							>
@@ -151,10 +148,7 @@ export default function ServiceTraces({
 									logEvent('Homepage: Learn more clicked', {
 										source: 'Service Traces',
 									});
-									window.open(
-										'https://signoz.io/docs/instrumentation/overview/',
-										'_blank',
-									);
+									openExternalLink('https://signoz.io/docs/instrumentation/overview/');
 								}}
 							>
 								Learn more <ArrowUpRight size={12} />

frontend/src/container/InfraMonitoringK8s/Clusters/ClusterDetails/ClusterDetails.tsx

@@ -49,6 +49,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import ClusterEvents from '../../EntityDetailsUtils/EntityEvents';
@@ -414,10 +415,7 @@ function ClusterDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -436,10 +434,7 @@ function ClusterDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/InfraMonitoringK8s/DaemonSets/DaemonSetDetails/DaemonSetDetails.tsx

@@ -48,6 +48,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import DaemonSetEvents from '../../EntityDetailsUtils/EntityEvents';
@@ -429,10 +430,7 @@ function DaemonSetDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -451,10 +449,7 @@ function DaemonSetDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/InfraMonitoringK8s/Deployments/DeploymentDetails/DeploymentDetails.tsx

@@ -50,6 +50,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import DeploymentEvents from '../../EntityDetailsUtils/EntityEvents';
@@ -433,10 +434,7 @@ function DeploymentDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -455,10 +453,7 @@ function DeploymentDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/InfraMonitoringK8s/Jobs/JobDetails/JobDetails.tsx

@@ -48,6 +48,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import JobEvents from '../../EntityDetailsUtils/EntityEvents';
@@ -427,10 +428,7 @@ function JobDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -449,10 +447,7 @@ function JobDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/InfraMonitoringK8s/Namespaces/NamespaceDetails/NamespaceDetails.tsx

@@ -50,6 +50,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import NamespaceEvents from '../../EntityDetailsUtils/EntityEvents';
@@ -419,10 +420,7 @@ function NamespaceDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -441,10 +439,7 @@ function NamespaceDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails.tsx

@@ -50,6 +50,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import NodeLogs from '../../EntityDetailsUtils/EntityLogs';
@@ -416,10 +417,7 @@ function NodeDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -438,10 +436,7 @@ function NodeDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodDetails.tsx

@@ -50,6 +50,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import PodEvents from '../../EntityDetailsUtils/EntityEvents';
@@ -435,10 +436,7 @@ function PodDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -457,10 +455,7 @@ function PodDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/InfraMonitoringK8s/StatefulSets/StatefulSetDetails/StatefulSetDetails.tsx

@@ -53,6 +53,7 @@ import {
 	TracesAggregatorOperator,
 } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
+import { openInNewTab } from 'utils/navigation';
 import { v4 as uuidv4 } from 'uuid';
 
 import {
@@ -431,10 +432,7 @@ function StatefulSetDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`);
 		} else if (selectedView === VIEW_TYPES.TRACES) {
 			const compositeQuery = {
 				...initialQueryState,
@@ -453,10 +451,7 @@ function StatefulSetDetails({
 
 			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
 
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
+			openInNewTab(`${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`);
 		}
 	};
 

frontend/src/container/ListAlertRules/AlertsEmptyState/AlertInfoCard.tsx

@@ -1,5 +1,6 @@
 import { ArrowRightOutlined } from '@ant-design/icons';
 import { Typography } from 'antd';
+import { openExternalLink } from 'utils/navigation';
 
 interface AlertInfoCardProps {
 	header: string;
@@ -19,7 +20,7 @@ function AlertInfoCard({
 			className="alert-info-card"
 			onClick={(): void => {
 				onClick();
-				window.open(link, '_blank');
+				openExternalLink(link);
 			}}
 		>
 			<div className="alert-card-text">

frontend/src/container/ListAlertRules/AlertsEmptyState/InfoLinkText.tsx

@@ -1,5 +1,6 @@
 import { ArrowRightOutlined, PlayCircleFilled } from '@ant-design/icons';
 import { Flex, Typography } from 'antd';
+import { openExternalLink } from 'utils/navigation';
 
 interface InfoLinkTextProps {
 	infoText: string;
@@ -20,7 +21,7 @@ function InfoLinkText({
 		<Flex
 			onClick={(): void => {
 				onClick();
-				window.open(link, '_blank');
+				openExternalLink(link);
 			}}
 			className="info-link-container"
 		>

frontend/src/container/ListAlertRules/DeleteAlert.tsx

@@ -1,16 +1,9 @@
 import { Dispatch, SetStateAction, useState } from 'react';
 import type { NotificationInstance } from 'antd/es/notification/interface';
-import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
-import { deleteRuleByID } from 'api/generated/services/rules';
-import type {
-	RenderErrorResponseDTO,
-	RuletypesGettableRuleDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { AxiosError } from 'axios';
+import deleteAlerts from 'api/alerts/delete';
 import { State } from 'hooks/useFetch';
-import { useErrorModal } from 'providers/ErrorModalProvider';
 import { PayloadProps as DeleteAlertPayloadProps } from 'types/api/alerts/delete';
-import APIError from 'types/api/error';
+import { GettableAlert } from 'types/api/alerts/get';
 
 import { ColumnButton } from './styles';
 
@@ -29,31 +22,48 @@ function DeleteAlert({
 		payload: undefined,
 	});
 
-	const { showErrorModal } = useErrorModal();
+	const defaultErrorMessage = 'Something went wrong';
 
 	const onDeleteHandler = async (id: string): Promise<void> => {
 		try {
-			await deleteRuleByID({ id });
-
-			setData((state) => state.filter((alert) => alert.id !== id));
-
-			setDeleteAlertState((state) => ({
-				...state,
-				loading: false,
-			}));
-			notifications.success({
-				message: 'Success',
+			const response = await deleteAlerts({
+				id,
 			});
+
+			if (response.statusCode === 200) {
+				setData((state) => state.filter((alert) => alert.id !== id));
+
+				setDeleteAlertState((state) => ({
+					...state,
+					loading: false,
+					payload: response.payload,
+				}));
+				notifications.success({
+					message: 'Success',
+				});
+			} else {
+				setDeleteAlertState((state) => ({
+					...state,
+					loading: false,
+					error: true,
+					errorMessage: response.error || defaultErrorMessage,
+				}));
+
+				notifications.error({
+					message: response.error || defaultErrorMessage,
+				});
+			}
 		} catch (error) {
 			setDeleteAlertState((state) => ({
 				...state,
 				loading: false,
 				error: true,
+				errorMessage: defaultErrorMessage,
 			}));
 
-			showErrorModal(
-				convertToApiError(error as AxiosError<RenderErrorResponseDTO>) as APIError,
-			);
+			notifications.error({
+				message: defaultErrorMessage,
+			});
 		}
 	};
 
@@ -78,8 +88,8 @@ function DeleteAlert({
 }
 
 interface DeleteAlertProps {
-	id: string;
-	setData: Dispatch<SetStateAction<RuletypesGettableRuleDTO[]>>;
+	id: GettableAlert['id'];
+	setData: Dispatch<SetStateAction<GettableAlert[]>>;
 	notifications: NotificationInstance;
 }
 

frontend/src/container/ListAlertRules/ListAlert.tsx

@@ -4,17 +4,8 @@ import { UseQueryResult } from 'react-query';
 import { PlusOutlined } from '@ant-design/icons';
 import { Button, Flex, Input, Typography } from 'antd';
 import type { ColumnsType } from 'antd/es/table/interface';
+import saveAlertApi from 'api/alerts/save';
 import logEvent from 'api/common/logEvent';
-import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
-import { createRule } from 'api/generated/services/rules';
-import type {
-	ListRules200,
-	RenderErrorResponseDTO,
-	RuletypesGettableRuleDTO,
-	RuletypesPostableRuleDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import type { ErrorType } from 'api/generatedAPIInstance';
-import { AxiosError } from 'axios';
 import DropDown from 'components/DropDown/DropDown';
 import {
 	DynamicColumnsKey,
@@ -36,10 +27,9 @@ import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { mapQueryDataFromApi } from 'lib/newQueryBuilder/queryBuilderMappers/mapQueryDataFromApi';
 import { useAppContext } from 'providers/App/App';
-import { useErrorModal } from 'providers/ErrorModalProvider';
+import { ErrorResponse, SuccessResponse } from 'types/api';
 import { AlertTypes } from 'types/api/alerts/alertTypes';
-import type { ICompositeMetricQuery } from 'types/api/alerts/compositeQuery';
-import APIError from 'types/api/error';
+import { GettableAlert } from 'types/api/alerts/get';
 import { isModifierKeyPressed } from 'utils/app';
 
 import DeleteAlert from './DeleteAlert';
@@ -68,7 +58,7 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 	const paginationParam = params.get('page');
 	const searchParams = params.get('search');
 	const [searchString, setSearchString] = useState<string>(searchParams || '');
-	const [data, setData] = useState<RuletypesGettableRuleDTO[]>(() => {
+	const [data, setData] = useState<GettableAlert[]>(() => {
 		const value = searchString.toLowerCase();
 		const filteredData = filterAlerts(allAlertRules, value);
 		return filteredData || [];
@@ -80,10 +70,7 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 			? orderQueryParam
 			: null;
 
-	const {
-		sortedInfo,
-		handleChange,
-	} = useSortableTable<RuletypesGettableRuleDTO>(
+	const { sortedInfo, handleChange } = useSortableTable<GettableAlert>(
 		sortingOrder,
 		orderColumnParam || '',
 		searchString,
@@ -96,7 +83,7 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 			const { data: refetchData, status } = await refetch();
 			if (status === 'success') {
 				const value = searchString.toLowerCase();
-				const filteredData = filterAlerts(refetchData?.data?.rules ?? [], value);
+				const filteredData = filterAlerts(refetchData.payload || [], value);
 				setData(filteredData || []);
 			}
 			if (status === 'error') {
@@ -107,7 +94,11 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 		})();
 	}, 30000);
 
-	const { showErrorModal } = useErrorModal();
+	const handleError = useCallback((): void => {
+		notificationsApi.error({
+			message: t('something_went_wrong'),
+		});
+	}, [notificationsApi, t]);
 
 	const onClickNewAlertHandler = useCallback(
 		(e: React.MouseEvent): void => {
@@ -124,13 +115,11 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 	);
 
 	const onEditHandler = (
-		record: RuletypesGettableRuleDTO,
+		record: GettableAlert,
 		options?: { newTab?: boolean },
 	): void => {
 		const compositeQuery = sanitizeDefaultAlertQuery(
-			mapQueryDataFromApi(
-				(record.condition?.compositeQuery as unknown) as ICompositeMetricQuery,
-			),
+			mapQueryDataFromApi(record.condition.compositeQuery),
 			record.alertType as AlertTypes,
 		);
 		params.set(
@@ -138,12 +127,9 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 			encodeURIComponent(JSON.stringify(compositeQuery)),
 		);
 
-		const panelType = record.condition?.compositeQuery?.panelType;
-		if (panelType) {
-			params.set(QueryParams.panelTypes, panelType);
-		}
+		params.set(QueryParams.panelTypes, record.condition.compositeQuery.panelType);
 
-		params.set(QueryParams.ruleId, record.id ?? '');
+		params.set(QueryParams.ruleId, record.id.toString());
 
 		setEditLoader(false);
 
@@ -153,41 +139,47 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 	};
 
 	const onCloneHandler = (
-		originalAlert: RuletypesGettableRuleDTO,
+		originalAlert: GettableAlert,
 	) => async (): Promise<void> => {
-		const copyAlert: RuletypesGettableRuleDTO = {
+		const copyAlert = {
 			...originalAlert,
-			alert: `${originalAlert.alert ?? ''} - Copy`,
+			alert: originalAlert.alert.concat(' - Copy'),
 		};
+		const apiReq = { data: copyAlert };
 
 		try {
 			setCloneLoader(true);
-			await createRule((copyAlert as unknown) as RuletypesPostableRuleDTO);
+			const response = await saveAlertApi(apiReq);
 
-			notificationsApi.success({
-				message: 'Success',
-				description: 'Alert cloned successfully',
-			});
+			if (response.statusCode === 200) {
+				notificationsApi.success({
+					message: 'Success',
+					description: 'Alert cloned successfully',
+				});
 
-			const { data: refetchData, status } = await refetch();
-			const rules = refetchData?.data?.rules;
-			if (status === 'success' && rules) {
-				setData(rules);
-				setTimeout(() => {
-					const clonedAlert = rules[rules.length - 1];
-					params.set(QueryParams.ruleId, String(clonedAlert.id));
-					safeNavigate(`${ROUTES.EDIT_ALERTS}?${params.toString()}`);
-				}, 2000);
-			}
-			if (status === 'error') {
+				const { data: refetchData, status } = await refetch();
+				if (status === 'success' && refetchData.payload) {
+					setData(refetchData.payload || []);
+					setTimeout(() => {
+						const clonedAlert = refetchData.payload[refetchData.payload.length - 1];
+						params.set(QueryParams.ruleId, String(clonedAlert.id));
+						safeNavigate(`${ROUTES.EDIT_ALERTS}?${params.toString()}`);
+					}, 2000);
+				}
+				if (status === 'error') {
+					notificationsApi.error({
+						message: t('something_went_wrong'),
+					});
+				}
+			} else {
 				notificationsApi.error({
-					message: t('something_went_wrong'),
+					message: 'Error',
+					description: response.error || t('something_went_wrong'),
 				});
 			}
 		} catch (error) {
-			showErrorModal(
-				convertToApiError(error as AxiosError<RenderErrorResponseDTO>) as APIError,
-			);
+			handleError();
+			console.error(error);
 		} finally {
 			setCloneLoader(false);
 		}
@@ -200,19 +192,16 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 		setData(filteredData);
 	});
 
-	const dynamicColumns: ColumnsType<RuletypesGettableRuleDTO> = [
+	const dynamicColumns: ColumnsType<GettableAlert> = [
 		{
 			title: 'Created At',
 			dataIndex: 'createAt',
 			width: 80,
 			key: DynamicColumnsKey.CreatedAt,
 			align: 'center',
-			sorter: (
-				a: RuletypesGettableRuleDTO,
-				b: RuletypesGettableRuleDTO,
-			): number => {
-				const prev = a.createAt ? new Date(a.createAt).getTime() : 0;
-				const next = b.createAt ? new Date(b.createAt).getTime() : 0;
+			sorter: (a: GettableAlert, b: GettableAlert): number => {
+				const prev = new Date(a.createAt).getTime();
+				const next = new Date(b.createAt).getTime();
 
 				return prev - next;
 			},
@@ -235,12 +224,9 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 			width: 80,
 			key: DynamicColumnsKey.UpdatedAt,
 			align: 'center',
-			sorter: (
-				a: RuletypesGettableRuleDTO,
-				b: RuletypesGettableRuleDTO,
-			): number => {
-				const prev = a.updateAt ? new Date(a.updateAt).getTime() : 0;
-				const next = b.updateAt ? new Date(b.updateAt).getTime() : 0;
+			sorter: (a: GettableAlert, b: GettableAlert): number => {
+				const prev = new Date(a.updateAt).getTime();
+				const next = new Date(b.updateAt).getTime();
 
 				return prev - next;
 			},
@@ -259,7 +245,7 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 		},
 	];
 
-	const columns: ColumnsType<RuletypesGettableRuleDTO> = [
+	const columns: ColumnsType<GettableAlert> = [
 		{
 			title: 'Status',
 			dataIndex: 'state',
@@ -336,7 +322,7 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 			dataIndex: 'id',
 			key: 'action',
 			width: 10,
-			render: (id: RuletypesGettableRuleDTO['id'], record): JSX.Element => (
+			render: (id: GettableAlert['id'], record): JSX.Element => (
 				<div data-testid="alert-actions">
 					<DropDown
 						onDropDownItemClick={(item): void =>
@@ -345,9 +331,9 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 						element={[
 							<ToggleAlertState
 								key="1"
-								disabled={record.disabled ?? false}
+								disabled={record.disabled}
 								setData={setData}
-								id={id ?? ''}
+								id={id}
 							/>,
 							<ColumnButton
 								key="2"
@@ -379,7 +365,7 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 								key="4"
 								notifications={notificationsApi}
 								setData={setData}
-								id={id ?? ''}
+								id={id}
 							/>,
 						]}
 					/>
@@ -434,10 +420,9 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 }
 
 interface ListAlertProps {
-	allAlertRules: RuletypesGettableRuleDTO[];
+	allAlertRules: GettableAlert[];
 	refetch: UseQueryResult<
-		ListRules200,
-		ErrorType<RenderErrorResponseDTO>
+		ErrorResponse | SuccessResponse<GettableAlert[]>
 	>['refetch'];
 }
 

frontend/src/container/ListAlertRules/TableComponents/Status.tsx

@@ -1,5 +1,5 @@
 import { Tag } from 'antd';
-import type { RuletypesGettableRuleDTO } from 'api/generated/services/sigNoz.schemas';
+import { GettableAlert } from 'types/api/alerts/get';
 
 function Status({ status }: StatusProps): JSX.Element {
 	switch (status) {
@@ -26,7 +26,7 @@ function Status({ status }: StatusProps): JSX.Element {
 }
 
 interface StatusProps {
-	status: RuletypesGettableRuleDTO['state'];
+	status: GettableAlert['state'];
 }
 
 export default Status;

frontend/src/container/ListAlertRules/ToggleAlertState.tsx

@@ -1,16 +1,9 @@
 import { Dispatch, SetStateAction, useState } from 'react';
-import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
-import { patchRuleByID } from 'api/generated/services/rules';
-import type {
-	RenderErrorResponseDTO,
-	RuletypesGettableRuleDTO,
-	RuletypesPostableRuleDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { AxiosError } from 'axios';
+import patchAlert from 'api/alerts/patch';
 import { State } from 'hooks/useFetch';
 import { useNotifications } from 'hooks/useNotifications';
-import { useErrorModal } from 'providers/ErrorModalProvider';
-import APIError from 'types/api/error';
+import { GettableAlert } from 'types/api/alerts/get';
+import { PayloadProps as PatchPayloadProps } from 'types/api/alerts/patch';
 
 import { ColumnButton } from './styles';
 
@@ -19,7 +12,7 @@ function ToggleAlertState({
 	disabled,
 	setData,
 }: ToggleAlertStateProps): JSX.Element {
-	const [apiStatus, setAPIStatus] = useState<State<RuletypesGettableRuleDTO>>({
+	const [apiStatus, setAPIStatus] = useState<State<PatchPayloadProps>>({
 		error: false,
 		errorMessage: '',
 		loading: false,
@@ -28,7 +21,8 @@ function ToggleAlertState({
 	});
 
 	const { notifications } = useNotifications();
-	const { showErrorModal } = useErrorModal();
+
+	const defaultErrorMessage = 'Something went wrong';
 
 	const onToggleHandler = async (
 		id: string,
@@ -40,42 +34,58 @@ function ToggleAlertState({
 				loading: true,
 			}));
 
-			const response = await patchRuleByID({ id }, ({
-				disabled,
-			} as unknown) as RuletypesPostableRuleDTO);
-			const { data: updatedRule } = response;
-
-			setData((state) =>
-				state.map((alert) => {
-					if (alert.id === id) {
-						return {
-							...alert,
-							disabled: updatedRule.disabled,
-							state: updatedRule.state,
-						};
-					}
-					return alert;
-				}),
-			);
-
-			setAPIStatus((state) => ({
-				...state,
-				loading: false,
-				payload: updatedRule,
-			}));
-			notifications.success({
-				message: 'Success',
+			const response = await patchAlert({
+				id,
+				data: {
+					disabled,
+				},
 			});
+
+			if (response.statusCode === 200) {
+				setData((state) =>
+					state.map((alert) => {
+						if (alert.id === id) {
+							return {
+								...alert,
+								disabled: response.payload.disabled,
+								state: response.payload.state,
+							};
+						}
+						return alert;
+					}),
+				);
+
+				setAPIStatus((state) => ({
+					...state,
+					loading: false,
+					payload: response.payload,
+				}));
+				notifications.success({
+					message: 'Success',
+				});
+			} else {
+				setAPIStatus((state) => ({
+					...state,
+					loading: false,
+					error: true,
+					errorMessage: response.error || defaultErrorMessage,
+				}));
+
+				notifications.error({
+					message: response.error || defaultErrorMessage,
+				});
+			}
 		} catch (error) {
 			setAPIStatus((state) => ({
 				...state,
 				loading: false,
 				error: true,
+				errorMessage: defaultErrorMessage,
 			}));
 
-			showErrorModal(
-				convertToApiError(error as AxiosError<RenderErrorResponseDTO>) as APIError,
-			);
+			notifications.error({
+				message: defaultErrorMessage,
+			});
 		}
 	};
 
@@ -92,9 +102,9 @@ function ToggleAlertState({
 }
 
 interface ToggleAlertStateProps {
-	id: string;
+	id: GettableAlert['id'];
 	disabled: boolean;
-	setData: Dispatch<SetStateAction<RuletypesGettableRuleDTO[]>>;
+	setData: Dispatch<SetStateAction<GettableAlert[]>>;
 }
 
 export default ToggleAlertState;

frontend/src/container/ListAlertRules/__test__/utils.test.ts

@@ -1,24 +1,19 @@
-import type {
-	RuletypesAlertStateDTO,
-	RuletypesGettableRuleDTO,
-} from 'api/generated/services/sigNoz.schemas';
+import { GettableAlert } from 'types/api/alerts/get';
 
 import { filterAlerts } from '../utils';
 
 describe('filterAlerts', () => {
-	const mockAlertBase: Partial<RuletypesGettableRuleDTO> = {
-		state: 'active' as RuletypesAlertStateDTO,
+	const mockAlertBase: Partial<GettableAlert> = {
+		state: 'active',
 		disabled: false,
-		createAt: new Date('2024-01-01T00:00:00Z'),
+		createAt: '2024-01-01T00:00:00Z',
 		createBy: 'test-user',
-		updateAt: new Date('2024-01-01T00:00:00Z'),
+		updateAt: '2024-01-01T00:00:00Z',
 		updateBy: 'test-user',
 		version: '1',
-		condition: {},
-		ruleType: 'threshold_rule' as RuletypesGettableRuleDTO['ruleType'],
 	};
 
-	const mockAlerts: RuletypesGettableRuleDTO[] = [
+	const mockAlerts: GettableAlert[] = [
 		{
 			...mockAlertBase,
 			id: '1',
@@ -29,7 +24,7 @@ describe('filterAlerts', () => {
 				status: 'ok',
 				environment: 'production',
 			},
-		} as RuletypesGettableRuleDTO,
+		} as GettableAlert,
 		{
 			...mockAlertBase,
 			id: '2',
@@ -40,7 +35,7 @@ describe('filterAlerts', () => {
 				status: 'firing',
 				environment: 'staging',
 			},
-		} as RuletypesGettableRuleDTO,
+		} as GettableAlert,
 		{
 			...mockAlertBase,
 			id: '3',
@@ -51,7 +46,7 @@ describe('filterAlerts', () => {
 				status: 'pending',
 				environment: 'production',
 			},
-		} as RuletypesGettableRuleDTO,
+		} as GettableAlert,
 	];
 
 	it('should return all alerts when filter is empty', () => {
@@ -102,14 +97,14 @@ describe('filterAlerts', () => {
 	});
 
 	it('should handle alerts with missing labels', () => {
-		const alertsWithMissingLabels: RuletypesGettableRuleDTO[] = [
+		const alertsWithMissingLabels: GettableAlert[] = [
 			{
 				...mockAlertBase,
 				id: '4',
 				alert: 'Test Alert',
 				alertType: 'metrics',
 				labels: undefined,
-			} as RuletypesGettableRuleDTO,
+			} as GettableAlert,
 		];
 		const result = filterAlerts(alertsWithMissingLabels, 'test');
 		expect(result).toHaveLength(1);
@@ -117,7 +112,7 @@ describe('filterAlerts', () => {
 	});
 
 	it('should handle alerts with missing alert name', () => {
-		const alertsWithMissingName: RuletypesGettableRuleDTO[] = [
+		const alertsWithMissingName: GettableAlert[] = [
 			{
 				...mockAlertBase,
 				id: '5',
@@ -126,7 +121,7 @@ describe('filterAlerts', () => {
 				labels: {
 					severity: 'warning',
 				},
-			} as RuletypesGettableRuleDTO,
+			} as GettableAlert,
 		];
 		const result = filterAlerts(alertsWithMissingName, 'warning');
 		expect(result).toHaveLength(1);

frontend/src/container/ListAlertRules/index.tsx

@@ -1,66 +1,78 @@
-import { useEffect, useMemo, useRef } from 'react';
+import { useEffect, useRef } from 'react';
 import { useTranslation } from 'react-i18next';
+import { useQuery } from 'react-query';
 import { Space } from 'antd';
+import getAll from 'api/alerts/getAll';
 import logEvent from 'api/common/logEvent';
-import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
-import { useListRules } from 'api/generated/services/rules';
-import { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
-import { AxiosError } from 'axios';
 import Spinner from 'components/Spinner';
 import { useNotifications } from 'hooks/useNotifications';
+import { isUndefined } from 'lodash-es';
 
 import { AlertsEmptyState } from './AlertsEmptyState/AlertsEmptyState';
 import ListAlert from './ListAlert';
 
 function ListAlertRules(): JSX.Element {
 	const { t } = useTranslation('common');
-	const { data, isError, isLoading, refetch, error } = useListRules({
-		query: { cacheTime: 0 },
+	const { data, isError, isLoading, refetch, status } = useQuery('allAlerts', {
+		queryFn: getAll,
+		cacheTime: 0,
 	});
 
-	const rules = data?.data?.rules ?? [];
-	const hasLoaded = !isLoading && data !== undefined;
 	const logEventCalledRef = useRef(false);
 
 	const { notifications } = useNotifications();
 
-	const apiError = useMemo(
-		() => convertToApiError(error as AxiosError<RenderErrorResponseDTO> | null),
-		[error],
-	);
-
 	useEffect(() => {
-		if (!logEventCalledRef.current && hasLoaded) {
+		if (!logEventCalledRef.current && !isUndefined(data?.payload)) {
 			logEvent('Alert: List page visited', {
-				number: rules.length,
+				number: data?.payload?.length,
 			});
 			logEventCalledRef.current = true;
 		}
-	}, [hasLoaded, rules.length]);
+	}, [data?.payload]);
 
 	useEffect(() => {
-		if (isError) {
+		if (status === 'error' || (status === 'success' && data.statusCode >= 400)) {
 			notifications.error({
-				message: apiError?.getErrorMessage() || t('something_went_wrong'),
+				message: data?.error || t('something_went_wrong'),
 			});
 		}
-	}, [isError, apiError, t, notifications]);
+	}, [data?.error, data?.statusCode, status, t, notifications]);
 
+	// api failed to load the data
 	if (isError) {
-		return <div>{apiError?.getErrorMessage() || t('something_went_wrong')}</div>;
+		return <div>{data?.error || t('something_went_wrong')}</div>;
 	}
 
-	if (isLoading || !data) {
-		return <Spinner height="75vh" tip="Loading Rules..." />;
+	// api is successful but error is present
+	if (status === 'success' && data.statusCode >= 400) {
+		return (
+			<ListAlert
+				{...{
+					allAlertRules: [],
+					refetch,
+				}}
+			/>
+		);
 	}
 
-	if (rules.length === 0) {
+	if (status === 'success' && !data.payload?.length) {
 		return <AlertsEmptyState />;
 	}
 
+	// in case of loading
+	if (isLoading || !data?.payload) {
+		return <Spinner height="75vh" tip="Loading Rules..." />;
+	}
+
 	return (
 		<Space direction="vertical" size="large" style={{ width: '100%' }}>
-			<ListAlert allAlertRules={rules} refetch={refetch} />
+			<ListAlert
+				{...{
+					allAlertRules: data.payload,
+					refetch,
+				}}
+			/>
 		</Space>
 	);
 }

frontend/src/container/ListAlertRules/utils.ts

@@ -1,12 +1,12 @@
 import logEvent from 'api/common/logEvent';
-import type { RuletypesGettableRuleDTO } from 'api/generated/services/sigNoz.schemas';
 import { ALERTS_DATA_SOURCE_MAP } from 'constants/alerts';
 import { AlertTypes } from 'types/api/alerts/alertTypes';
+import { GettableAlert } from 'types/api/alerts/get';
 
 export const filterAlerts = (
-	allAlertRules: RuletypesGettableRuleDTO[],
+	allAlertRules: GettableAlert[],
 	filter: string,
-): RuletypesGettableRuleDTO[] => {
+): GettableAlert[] => {
 	if (!filter.trim()) {
 		return allAlertRules;
 	}
@@ -32,7 +32,7 @@ export const filterAlerts = (
 
 export const alertActionLogEvent = (
 	action: string,
-	record: RuletypesGettableRuleDTO,
+	record: GettableAlert,
 ): void => {
 	let actionValue = '';
 	switch (action) {

frontend/src/container/ListOfDashboard/DashboardsList.tsx

@@ -83,6 +83,7 @@ import {
 } from 'types/api/dashboard/getAll';
 import APIError from 'types/api/error';
 import { isModifierKeyPressed } from 'utils/app';
+import { openExternalLink, openInNewTab } from 'utils/navigation';
 
 import awwSnapUrl from '@/assets/Icons/awwSnap.svg';
 import dashboardsUrl from '@/assets/Icons/dashboards.svg';
@@ -457,7 +458,7 @@ function DashboardsList(): JSX.Element {
 													onClick={(e): void => {
 														e.stopPropagation();
 														e.preventDefault();
-														window.open(getLink(), '_blank');
+														openInNewTab(getLink());
 													}}
 												>
 													Open in New Tab
@@ -739,9 +740,8 @@ function DashboardsList(): JSX.Element {
 									className="learn-more"
 									data-testid="learn-more"
 									onClick={(): void => {
-										window.open(
+										openExternalLink(
 											'https://signoz.io/docs/userguide/manage-dashboards?utm_source=product&utm_medium=dashboard-list-empty-state',
-											'_blank',
 										);
 									}}
 								>

frontend/src/container/ListOfDashboard/TableComponents/Name.tsx

@@ -1,6 +1,7 @@
 import { LockFilled } from '@ant-design/icons';
 import ROUTES from 'constants/routes';
 import history from 'lib/history';
+import { openInNewTab } from 'utils/navigation';
 
 import { Data } from '../DashboardsList';
 import { TableLinkText } from './styles';
@@ -12,7 +13,7 @@ function Name(name: Data['name'], data: Data): JSX.Element {
 
 	const onClickHandler = (event: React.MouseEvent<HTMLElement>): void => {
 		if (event.metaKey || event.ctrlKey) {
-			window.open(getLink(), '_blank');
+			openInNewTab(getLink());
 		} else {
 			history.push(getLink());
 		}

frontend/src/container/LogDetailedView/ContextView/ContextLogRenderer.tsx

@@ -17,6 +17,7 @@ import useUrlQuery from 'hooks/useUrlQuery';
 import { ILog } from 'types/api/logs/log';
 import { Query, TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource, StringOperators } from 'types/common/queryBuilder';
+import { openInNewTab } from 'utils/navigation';
 
 import { useContextLogData } from './useContextLogData';
 
@@ -116,7 +117,7 @@ function ContextLogRenderer({
 			);
 
 			const link = `${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`;
-			window.open(link, '_blank', 'noopener,noreferrer');
+			openInNewTab(link);
 		},
 		[query, urlQuery],
 	);

frontend/src/container/LogDetailedView/TableView.tsx

@@ -34,6 +34,7 @@ import { SET_DETAILED_LOG_DATA } from 'types/actions/logs';
 import { IField } from 'types/api/logs/fields';
 import { ILog } from 'types/api/logs/log';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { openInNewTab } from 'utils/navigation';
 
 import { ActionItemProps } from './ActionItem';
 import FieldRenderer from './FieldRenderer';
@@ -191,7 +192,7 @@ function TableView({
 
 			if (event.ctrlKey || event.metaKey) {
 				// open the trace in new tab
-				window.open(route, '_blank');
+				openInNewTab(route);
 			} else {
 				history.push(route);
 			}

frontend/src/container/LogsError/LogsError.tsx

@@ -2,6 +2,7 @@ import { Typography } from 'antd';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import history from 'lib/history';
 import { ArrowRight } from 'lucide-react';
+import { openExternalLink } from 'utils/navigation';
 
 import awwSnapUrl from '@/assets/Icons/awwSnap.svg';
 
@@ -14,7 +15,7 @@ export default function LogsError(): JSX.Element {
 		if (isCloudUserVal) {
 			history.push('/support');
 		} else {
-			window.open('https://signoz.io/slack', '_blank');
+			openExternalLink('https://signoz.io/slack');
 		}
 	};
 

frontend/src/container/MetricsApplication/utils.ts

@@ -1,5 +1,6 @@
 import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
+import { openInNewTab as openInNewTabFn } from 'utils/navigation';
 
 import { TopOperationList } from './TopOperationsTable';
 import { NavigateToTraceProps } from './types';
@@ -37,7 +38,7 @@ export const navigateToTrace = ({
 	}=${JSONCompositeQuery}`;
 
 	if (openInNewTab) {
-		window.open(newTraceExplorerPath, '_blank');
+		openInNewTabFn(newTraceExplorerPath);
 	} else {
 		safeNavigate(newTraceExplorerPath);
 	}

frontend/src/container/MetricsExplorer/MetricDetails/DashboardsAndAlertsPopover.tsx

@@ -9,6 +9,7 @@ import {
 import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
 import { Bell, Grid } from 'lucide-react';
+import { openInNewTab } from 'utils/navigation';
 import { pluralize } from 'utils/pluralize';
 
 import { DashboardsAndAlertsPopoverProps } from './types';
@@ -67,9 +68,8 @@ function DashboardsAndAlertsPopover({
 					<Typography.Link
 						key={alert.alertId}
 						onClick={(): void => {
-							window.open(
+							openInNewTab(
 								`${ROUTES.ALERT_OVERVIEW}?${QueryParams.ruleId}=${alert.alertId}`,
-								'_blank',
 							);
 						}}
 						className="dashboards-popover-content-item"
@@ -90,11 +90,8 @@ function DashboardsAndAlertsPopover({
 					<Typography.Link
 						key={dashboard.dashboardId}
 						onClick={(): void => {
-							window.open(
-								generatePath(ROUTES.DASHBOARD, {
-									dashboardId: dashboard.dashboardId,
-								}),
-								'_blank',
+							openInNewTab(
+								generatePath(ROUTES.DASHBOARD, { dashboardId: dashboard.dashboardId }),
 							);
 						}}
 						className="dashboards-popover-content-item"

frontend/src/container/NoLogs/NoLogs.tsx

@@ -6,6 +6,7 @@ import history from 'lib/history';
 import { ArrowUpRight } from 'lucide-react';
 import { DataSource } from 'types/common/queryBuilder';
 import DOCLINKS from 'utils/docLinks';
+import { openExternalLink } from 'utils/navigation';
 
 import eyesEmojiUrl from '@/assets/Images/eyesEmoji.svg';
 
@@ -42,11 +43,11 @@ export default function NoLogs({
 			}
 			history.push(link);
 		} else if (dataSource === 'traces') {
-			window.open(DOCLINKS.TRACES_EXPLORER_EMPTY_STATE, '_blank');
+			openExternalLink(DOCLINKS.TRACES_EXPLORER_EMPTY_STATE);
 		} else if (dataSource === DataSource.METRICS) {
-			window.open(DOCLINKS.METRICS_EXPLORER_EMPTY_STATE, '_blank');
+			openExternalLink(DOCLINKS.METRICS_EXPLORER_EMPTY_STATE);
 		} else {
-			window.open(`${DOCLINKS.USER_GUIDE}${dataSource}/`, '_blank');
+			openExternalLink(`${DOCLINKS.USER_GUIDE}${dataSource}/`);
 		}
 	};
 	return (

frontend/src/container/OnboardingQuestionaire/OnboardingFooter/OnboardingFooter.tsx

@@ -1,3 +1,4 @@
+// hippa.svg and soc2.svg do not exist in src/assets — suppressed until assets are added
 import { Dot } from 'lucide-react';
 
 import './OnboardingFooter.styles.scss';
@@ -12,7 +13,6 @@ export function OnboardingFooter(): JSX.Element {
 					className="footer-content"
 					rel="noreferrer"
 				>
-					{/* hippa.svg does not exist in src/assets — suppressed until asset is added */}
 					{/* eslint-disable-next-line rulesdir/no-unsupported-asset-pattern */}
 					<img src="/logos/hippa.svg" alt="HIPPA" className="footer-logo" />
 					<span className="footer-text">HIPPA</span>
@@ -24,7 +24,6 @@ export function OnboardingFooter(): JSX.Element {
 					className="footer-content"
 					rel="noreferrer"
 				>
-					{/* soc2.svg does not exist in src/assets — suppressed until asset is added */}
 					{/* eslint-disable-next-line rulesdir/no-unsupported-asset-pattern */}
 					<img src="/logos/soc2.svg" alt="SOC2" className="footer-logo" />
 					<span className="footer-text">SOC2</span>

frontend/src/container/PlannedDowntime/PlannedDowntime.tsx

@@ -1,21 +1,21 @@
 import React, { ChangeEvent, useEffect, useState } from 'react';
+import { useQuery } from 'react-query';
 import { useHistory } from 'react-router-dom';
 import { PlusOutlined } from '@ant-design/icons';
 import { Color } from '@signozhq/design-tokens';
 import { Button, Flex, Form, Input, Tooltip, Typography } from 'antd';
+import getAll from 'api/alerts/getAll';
+import { useDeleteDowntimeSchedule } from 'api/plannedDowntime/deleteDowntimeSchedule';
 import {
-	useDeleteDowntimeScheduleByID,
-	useListDowntimeSchedules,
-} from 'api/generated/services/downtimeschedules';
-import { useListRules } from 'api/generated/services/rules';
-import type { RuletypesGettablePlannedMaintenanceDTO } from 'api/generated/services/sigNoz.schemas';
+	DowntimeSchedules,
+	useGetAllDowntimeSchedules,
+} from 'api/plannedDowntime/getAllDowntimeSchedules';
 import dayjs from 'dayjs';
 import useDebouncedFn from 'hooks/useDebouncedFunction';
 import { useNotifications } from 'hooks/useNotifications';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { Search } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
-import { useErrorModal } from 'providers/ErrorModalProvider';
 import { USER_ROLES } from 'types/roles';
 
 import 'dayjs/locale/en';
@@ -33,28 +33,28 @@ import './PlannedDowntime.styles.scss';
 dayjs.locale('en');
 
 export function PlannedDowntime(): JSX.Element {
-	const { data: alertsData, isError, isLoading } = useListRules({
-		query: { cacheTime: 0 },
+	const { data, isError, isLoading } = useQuery('allAlerts', {
+		queryFn: getAll,
+		cacheTime: 0,
 	});
 	const [isOpen, setIsOpen] = React.useState(false);
 	const [form] = Form.useForm();
 	const { user } = useAppContext();
-	const { showErrorModal } = useErrorModal();
 	const history = useHistory();
 	const urlQuery = useUrlQuery();
 
 	const [initialValues, setInitialValues] = useState<
-		Partial<RuletypesGettablePlannedMaintenanceDTO & { editMode: boolean }>
+		Partial<DowntimeSchedules & { editMode: boolean }>
 	>(defautlInitialValues);
 
-	const downtimeSchedules = useListDowntimeSchedules();
+	const downtimeSchedules = useGetAllDowntimeSchedules();
 	const alertOptions = React.useMemo(
 		() =>
-			alertsData?.data?.rules?.map((i: any) => ({
+			data?.payload?.map((i) => ({
 				label: i.alert,
 				value: i.id,
 			})),
-		[alertsData],
+		[data],
 	);
 
 	useEffect(() => {
@@ -66,7 +66,7 @@ export function PlannedDowntime(): JSX.Element {
 	const [searchValue, setSearchValue] = React.useState<string | number>(
 		urlQuery.get('search') || '',
 	);
-	const [deleteData, setDeleteData] = useState<{ id: string; name: string }>();
+	const [deleteData, setDeleteData] = useState<{ id: number; name: string }>();
 	const [isEditMode, setEditMode] = useState<boolean>(false);
 
 	const updateUrlWithSearch = useDebouncedFn((value) => {
@@ -105,13 +105,12 @@ export function PlannedDowntime(): JSX.Element {
 	const {
 		mutateAsync: deleteDowntimeScheduleAsync,
 		isLoading: isDeleteLoading,
-	} = useDeleteDowntimeScheduleByID();
+	} = useDeleteDowntimeSchedule({ id: deleteData?.id });
 
 	const onDeleteHandler = (): void => {
 		deleteDowntimeHandler({
 			deleteDowntimeScheduleAsync,
 			notifications,
-			showErrorModal,
 			refetchAllSchedules,
 			deleteId: deleteData?.id,
 			hideDeleteDowntimeScheduleModal,

frontend/src/container/PlannedDowntime/PlannedDowntimeForm.tsx

@@ -14,17 +14,11 @@ import {
 	Typography,
 } from 'antd';
 import type { DefaultOptionType } from 'antd/es/select';
-import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
 import {
-	createDowntimeSchedule,
-	updateDowntimeScheduleByID,
-} from 'api/generated/services/downtimeschedules';
-import type {
-	RuletypesGettablePlannedMaintenanceDTO,
-	RuletypesRecurrenceDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
-import { AxiosError } from 'axios';
+	DowntimeSchedules,
+	Recurrence,
+} from 'api/plannedDowntime/getAllDowntimeSchedules';
+import { DowntimeScheduleUpdatePayload } from 'api/plannedDowntime/updateDowntimeSchedule';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
 import {
 	ModalButtonWrapper,
@@ -35,14 +29,15 @@ import timezone from 'dayjs/plugin/timezone';
 import utc from 'dayjs/plugin/utc';
 import { useNotifications } from 'hooks/useNotifications';
 import { defaultTo, isEmpty } from 'lodash-es';
-import { useErrorModal } from 'providers/ErrorModalProvider';
-import APIError from 'types/api/error';
 import { ALL_TIME_ZONES } from 'utils/timeZoneUtil';
 
 import 'dayjs/locale/en';
 
+import { SOMETHING_WENT_WRONG } from '../../constants/api';
+import { showErrorNotification } from '../../utils/error';
 import { AlertRuleTags } from './PlannedDowntimeList';
 import {
+	createEditDowntimeSchedule,
 	getAlertOptionsFromIds,
 	getDurationInfo,
 	getEndTime,
@@ -67,9 +62,9 @@ interface PlannedDowntimeFormData {
 	name: string;
 	startTime: dayjs.Dayjs | string;
 	endTime: dayjs.Dayjs | string;
-	recurrence?: RuletypesRecurrenceDTO | null;
+	recurrence?: Recurrence | null;
 	alertRules: DefaultOptionType[];
-	recurrenceSelect?: RuletypesRecurrenceDTO;
+	recurrenceSelect?: Recurrence;
 	timezone?: string;
 }
 
@@ -77,7 +72,7 @@ const customFormat = DATE_TIME_FORMATS.ORDINAL_DATETIME;
 
 interface PlannedDowntimeFormProps {
 	initialValues: Partial<
-		RuletypesGettablePlannedMaintenanceDTO & {
+		DowntimeSchedules & {
 			editMode: boolean;
 		}
 	>;
@@ -117,7 +112,7 @@ export function PlannedDowntimeForm(
 	);
 
 	const [formData, setFormData] = useState<PlannedDowntimeFormData>(
-		(initialValues?.schedule as unknown) as PlannedDowntimeFormData,
+		initialValues?.schedule as PlannedDowntimeFormData,
 	);
 
 	const [recurrenceType, setRecurrenceType] = useState<string | null>(
@@ -130,7 +125,6 @@ export function PlannedDowntimeForm(
 		: undefined;
 
 	const { notifications } = useNotifications();
-	const { showErrorModal } = useErrorModal();
 
 	const datePickerFooter = (mode: any): any =>
 		mode === 'time' ? (
@@ -140,54 +134,57 @@ export function PlannedDowntimeForm(
 	const saveHanlder = useCallback(
 		async (values: PlannedDowntimeFormData) => {
 			const shouldKeepLocalTime = !isEditMode;
-			const data: RuletypesGettablePlannedMaintenanceDTO = {
-				alertIds: values.alertRules
-					.map((alert) => alert.value)
-					.filter((alert) => alert !== undefined) as string[],
-				name: values.name,
-				schedule: {
-					startTime: new Date(
-						handleTimeConversion(
+			const createEditProps: DowntimeScheduleUpdatePayload = {
+				data: {
+					alertIds: values.alertRules
+						.map((alert) => alert.value)
+						.filter((alert) => alert !== undefined) as string[],
+					name: values.name,
+					schedule: {
+						startTime: handleTimeConversion(
 							values.startTime,
 							timezoneInitialValue,
 							values.timezone,
 							shouldKeepLocalTime,
 						),
-					),
-					timezone: values.timezone,
-					endTime: values.endTime
-						? new Date(
-								handleTimeConversion(
+						timezone: values.timezone,
+						endTime: values.endTime
+							? handleTimeConversion(
 									values.endTime,
 									timezoneInitialValue,
 									values.timezone,
 									shouldKeepLocalTime,
-								),
-						  )
-						: undefined,
-					recurrence: values.recurrence as RuletypesRecurrenceDTO,
+							  )
+							: undefined,
+						recurrence: values.recurrence as Recurrence,
+					},
 				},
+				id: isEditMode ? initialValues.id : undefined,
 			};
 
 			setSaveLoading(true);
 			try {
-				if (isEditMode && initialValues.id) {
-					await updateDowntimeScheduleByID({ id: initialValues.id }, data);
+				const response = await createEditDowntimeSchedule({ ...createEditProps });
+				if (response.message === 'success') {
+					setIsOpen(false);
+					notifications.success({
+						message: 'Success',
+						description: isEditMode
+							? 'Schedule updated successfully'
+							: 'Schedule created successfully',
+					});
+					refetchAllSchedules();
 				} else {
-					await createDowntimeSchedule(data);
+					notifications.error({
+						message: 'Error',
+						description:
+							typeof response.error === 'string'
+								? response.error
+								: response.error?.message || SOMETHING_WENT_WRONG,
+					});
 				}
-				setIsOpen(false);
-				notifications.success({
-					message: 'Success',
-					description: isEditMode
-						? 'Schedule updated successfully'
-						: 'Schedule created successfully',
-				});
-				refetchAllSchedules();
 			} catch (e: unknown) {
-				showErrorModal(
-					convertToApiError(e as AxiosError<RenderErrorResponseDTO>) as APIError,
-				);
+				showErrorNotification(notifications, e as Error);
 			}
 			setSaveLoading(false);
 		},
@@ -198,11 +195,10 @@ export function PlannedDowntimeForm(
 			refetchAllSchedules,
 			setIsOpen,
 			timezoneInitialValue,
-			showErrorModal,
 		],
 	);
 	const onFinish = async (values: PlannedDowntimeFormData): Promise<void> => {
-		const recurrenceData =
+		const recurrenceData: Recurrence | undefined =
 			values?.recurrence?.repeatType === recurrenceOptions.doesNotRepeat.value
 				? undefined
 				: {
@@ -229,10 +225,7 @@ export function PlannedDowntimeForm(
 						repeatType: values.recurrence?.repeatType,
 				  };
 
-		const payloadValues = {
-			...values,
-			recurrence: recurrenceData as RuletypesRecurrenceDTO | undefined,
-		};
+		const payloadValues = { ...values, recurrence: recurrenceData };
 		await saveHanlder(payloadValues);
 	};
 
@@ -287,14 +280,13 @@ export function PlannedDowntimeForm(
 				? dayjs(initialValues.schedule?.startTime)
 				: '',
 			recurrence: {
-				...(initialValues.schedule?.recurrence as Record<string, unknown>),
+				...initialValues.schedule?.recurrence,
 				repeatType: !isScheduleRecurring(initialValues?.schedule)
 					? recurrenceOptions.doesNotRepeat.value
 					: (initialValues.schedule?.recurrence?.repeatType as string),
-				duration: String(
-					getDurationInfo(initialValues.schedule?.recurrence?.duration as string)
-						?.value ?? '',
-				),
+				duration: getDurationInfo(
+					initialValues.schedule?.recurrence?.duration as string,
+				)?.value,
 			},
 			timezone: initialValues.schedule?.timezone as string,
 		};
@@ -333,12 +325,7 @@ export function PlannedDowntimeForm(
 	const startTimeText = useMemo((): string => {
 		let startTime = formData?.startTime;
 		if (recurrenceType !== recurrenceOptions.doesNotRepeat.value) {
-			startTime =
-				(formData?.recurrence?.startTime
-					? dayjs(formData.recurrence.startTime).toISOString()
-					: '') ||
-				formData?.startTime ||
-				'';
+			startTime = formData?.recurrence?.startTime || formData?.startTime || '';
 		}
 
 		if (!startTime) {
@@ -394,10 +381,7 @@ export function PlannedDowntimeForm(
 	const endTimeText = useMemo((): string => {
 		let endTime = formData?.endTime;
 		if (recurrenceType !== recurrenceOptions.doesNotRepeat.value) {
-			endTime =
-				(formData?.recurrence?.endTime
-					? dayjs(formData.recurrence.endTime).toISOString()
-					: '') || '';
+			endTime = formData?.recurrence?.endTime || '';
 
 			if (!isEditMode && !endTime) {
 				endTime = formData?.endTime || '';

frontend/src/container/PlannedDowntime/PlannedDowntimeList.tsx

@@ -12,15 +12,13 @@ import {
 	Typography,
 } from 'antd';
 import type { DefaultOptionType } from 'antd/es/select';
-import type {
-	ListDowntimeSchedules200,
-	RenderErrorResponseDTO,
-	RuletypesGettablePlannedMaintenanceDTO,
-	RuletypesRecurrenceDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import type { ErrorType } from 'api/generatedAPIInstance';
+import {
+	DowntimeSchedules,
+	PayloadProps,
+	Recurrence,
+} from 'api/plannedDowntime/getAllDowntimeSchedules';
+import { AxiosError, AxiosResponse } from 'axios';
 import cx from 'classnames';
-import dayjs from 'dayjs';
 import { useNotifications } from 'hooks/useNotifications';
 import { defaultTo } from 'lodash-es';
 import { CalendarClock, PenLine, Trash2 } from 'lucide-react';
@@ -145,7 +143,7 @@ export function CollapseListContent({
 	created_by_name?: string;
 	created_by_email?: string;
 	timeframe: [string | undefined | null, string | undefined | null];
-	repeats?: RuletypesRecurrenceDTO | null;
+	repeats?: Recurrence | null;
 	updated_at?: string;
 	updated_by_name?: string;
 	alertOptions?: DefaultOptionType[];
@@ -220,10 +218,10 @@ export function CollapseListContent({
 export function CustomCollapseList(
 	props: DowntimeSchedulesTableData & {
 		setInitialValues: React.Dispatch<
-			React.SetStateAction<Partial<RuletypesGettablePlannedMaintenanceDTO>>
+			React.SetStateAction<Partial<DowntimeSchedules>>
 		>;
 		setModalOpen: React.Dispatch<React.SetStateAction<boolean>>;
-		handleDeleteDowntime: (id: string, name: string) => void;
+		handleDeleteDowntime: (id: number, name: string) => void;
 		setEditMode: React.Dispatch<React.SetStateAction<boolean>>;
 	},
 ): JSX.Element {
@@ -243,19 +241,12 @@ export function CustomCollapseList(
 		kind,
 	} = props;
 
-	const scheduleTime = schedule?.startTime
-		? dayjs(schedule.startTime).toISOString()
-		: createdAt
-		? dayjs(createdAt).toISOString()
-		: '';
+	const scheduleTime = schedule?.startTime ? schedule.startTime : createdAt;
 	// Combine time and date
 	const formattedDateAndTime = `Start time ⎯ ${formatDateTime(
 		defaultTo(scheduleTime, ''),
 	)} ${schedule?.timezone}`;
-	const endTime = getEndTime({
-		kind,
-		schedule,
-	} as Partial<RuletypesGettablePlannedMaintenanceDTO>);
+	const endTime = getEndTime({ kind, schedule });
 
 	return (
 		<>
@@ -266,10 +257,7 @@ export function CustomCollapseList(
 							duration={
 								schedule?.recurrence?.duration
 									? (schedule?.recurrence?.duration as string)
-									: getDuration(
-											schedule?.startTime ? dayjs(schedule.startTime).toISOString() : '',
-											schedule?.endTime ? dayjs(schedule.endTime).toISOString() : '',
-									  )
+									: getDuration(schedule?.startTime, schedule?.endTime)
 							}
 							name={defaultTo(name, '')}
 							handleEdit={(): void => {
@@ -278,23 +266,21 @@ export function CustomCollapseList(
 								setEditMode(true);
 							}}
 							handleDelete={(): void => {
-								handleDeleteDowntime(id ?? '', name || '');
+								handleDeleteDowntime(id, name || '');
 							}}
 						/>
 					}
-					key={id ?? ''}
+					key={id}
 				>
 					<CollapseListContent
-						created_at={createdAt ? dayjs(createdAt).toISOString() : ''}
+						created_at={defaultTo(createdAt, '')}
 						created_by_name={defaultTo(createdBy, '')}
 						timeframe={[
 							schedule?.startTime?.toString(),
 							typeof endTime === 'string' ? endTime : endTime?.toString(),
 						]}
-						repeats={
-							schedule?.recurrence as RuletypesRecurrenceDTO | null | undefined
-						}
-						updated_at={updatedAt ? dayjs(updatedAt).toISOString() : ''}
+						repeats={schedule?.recurrence}
+						updated_at={defaultTo(updatedAt, '')}
 						updated_by_name={defaultTo(updatedBy, '')}
 						alertOptions={alertOptions}
 						timezone={defaultTo(schedule?.timezone, '')}
@@ -309,7 +295,7 @@ export function CustomCollapseList(
 	);
 }
 
-export type DowntimeSchedulesTableData = RuletypesGettablePlannedMaintenanceDTO & {
+export type DowntimeSchedulesTableData = DowntimeSchedules & {
 	alertOptions: DefaultOptionType[];
 };
 
@@ -323,15 +309,15 @@ export function PlannedDowntimeList({
 	searchValue,
 }: {
 	downtimeSchedules: UseQueryResult<
-		ListDowntimeSchedules200,
-		ErrorType<RenderErrorResponseDTO>
+		AxiosResponse<PayloadProps, any>,
+		AxiosError<unknown, any>
 	>;
 	alertOptions: DefaultOptionType[];
 	setInitialValues: React.Dispatch<
-		React.SetStateAction<Partial<RuletypesGettablePlannedMaintenanceDTO>>
+		React.SetStateAction<Partial<DowntimeSchedules>>
 	>;
 	setModalOpen: React.Dispatch<React.SetStateAction<boolean>>;
-	handleDeleteDowntime: (id: string, name: string) => void;
+	handleDeleteDowntime: (id: number, name: string) => void;
 	setEditMode: React.Dispatch<React.SetStateAction<boolean>>;
 	searchValue: string | number;
 }): JSX.Element {
@@ -351,17 +337,17 @@ export function PlannedDowntimeList({
 	];
 	const { notifications } = useNotifications();
 
-	const tableData = [...(downtimeSchedules.data?.data || [])]
+	const tableData = (downtimeSchedules.data?.data?.data || [])
 		.sort((a, b): number => {
 			if (a?.updatedAt && b?.updatedAt) {
-				return dayjs(b.updatedAt).diff(dayjs(a.updatedAt));
+				return b.updatedAt.localeCompare(a.updatedAt);
 			}
 			return 0;
 		})
 		?.filter(
 			(data) =>
 				data?.name?.includes(searchValue.toLocaleString()) ||
-				String(data?.id ?? '') === searchValue.toLocaleString(),
+				data?.id.toLocaleString() === searchValue.toLocaleString(),
 		)
 		.map?.((data) => {
 			const specificAlertOptions = getAlertOptionsFromIds(

frontend/src/container/PlannedDowntime/PlannedDowntimeutils.ts

@@ -1,19 +1,21 @@
 import { UseMutateAsyncFunction } from 'react-query';
 import type { NotificationInstance } from 'antd/es/notification/interface';
 import type { DefaultOptionType } from 'antd/es/select';
-import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
-import type {
-	DeleteDowntimeScheduleByIDPathParameters,
-	RenderErrorResponseDTO,
-	RuletypesGettablePlannedMaintenanceDTO,
-	RuletypesRecurrenceDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import type { ErrorType } from 'api/generatedAPIInstance';
-import { AxiosError } from 'axios';
+import createDowntimeSchedule from 'api/plannedDowntime/createDowntimeSchedule';
+import { DeleteSchedulePayloadProps } from 'api/plannedDowntime/deleteDowntimeSchedule';
+import {
+	DowntimeSchedules,
+	Recurrence,
+} from 'api/plannedDowntime/getAllDowntimeSchedules';
+import updateDowntimeSchedule, {
+	DowntimeScheduleUpdatePayload,
+	PayloadProps,
+} from 'api/plannedDowntime/updateDowntimeSchedule';
+import { showErrorNotification } from 'components/ExplorerCard/utils';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
 import dayjs from 'dayjs';
 import { isEmpty, isEqual } from 'lodash-es';
-import APIError from 'types/api/error';
+import { ErrorResponse, SuccessResponse } from 'types/api';
 
 type DateTimeString = string | null | undefined;
 
@@ -59,54 +61,47 @@ export const getAlertOptionsFromIds = (
 			alertIds?.includes(alert.value as string),
 	);
 
-export const recurrenceInfo = (
-	recurrence?: RuletypesRecurrenceDTO | null,
-): string => {
+export const recurrenceInfo = (recurrence?: Recurrence | null): string => {
 	if (!recurrence) {
 		return 'No';
 	}
 
 	const { startTime, duration, repeatOn, repeatType, endTime } = recurrence;
 
-	const formattedStartTime = startTime
-		? formatDateTime(dayjs(startTime).toISOString())
-		: '';
-	const formattedEndTime = endTime
-		? `to ${formatDateTime(dayjs(endTime).toISOString())}`
-		: '';
+	const formattedStartTime = startTime ? formatDateTime(startTime) : '';
+	const formattedEndTime = endTime ? `to ${formatDateTime(endTime)}` : '';
 	const weeklyRepeatString = repeatOn ? `on ${repeatOn.join(', ')}` : '';
 	const durationString = duration ? `- Duration: ${duration}` : '';
 
 	return `Repeats - ${repeatType} ${weeklyRepeatString} from ${formattedStartTime} ${formattedEndTime} ${durationString}`;
 };
 
-export const defautlInitialValues = ({
+export const defautlInitialValues: Partial<
+	DowntimeSchedules & { editMode: boolean }
+> = {
 	name: '',
 	description: '',
 	schedule: {
 		timezone: '',
 		endTime: '',
-		recurrence: undefined,
+		recurrence: null,
 		startTime: '',
 	},
-	alertIds: [] as string[],
+	alertIds: [],
 	createdAt: '',
 	createdBy: '',
 	editMode: false,
-} as unknown) as Partial<
-	RuletypesGettablePlannedMaintenanceDTO & { editMode: boolean }
->;
+};
 
 type DeleteDowntimeScheduleProps = {
 	deleteDowntimeScheduleAsync: UseMutateAsyncFunction<
-		void,
-		ErrorType<RenderErrorResponseDTO>,
-		{ pathParams: DeleteDowntimeScheduleByIDPathParameters }
+		DeleteSchedulePayloadProps,
+		Error,
+		number
 	>;
 	notifications: NotificationInstance;
-	showErrorModal: (error: APIError) => void;
 	refetchAllSchedules: VoidFunction;
-	deleteId?: string;
+	deleteId?: number;
 	hideDeleteDowntimeScheduleModal: () => void;
 	clearSearch: () => void;
 };
@@ -118,33 +113,40 @@ export const deleteDowntimeHandler = ({
 	hideDeleteDowntimeScheduleModal,
 	clearSearch,
 	notifications,
-	showErrorModal,
 }: DeleteDowntimeScheduleProps): void => {
 	if (!deleteId) {
+		const errorMsg = new Error('Something went wrong');
 		console.error('Unable to delete, please provide correct deleteId');
-		notifications.error({ message: 'Something went wrong' });
+		showErrorNotification(notifications, errorMsg);
 	} else {
-		deleteDowntimeScheduleAsync(
-			{ pathParams: { id: String(deleteId) } },
-			{
-				onSuccess: () => {
-					hideDeleteDowntimeScheduleModal();
-					clearSearch();
-					notifications.success({
-						message: 'Downtime schedule Deleted Successfully',
-					});
-					refetchAllSchedules();
-				},
-				onError: (err) => {
-					showErrorModal(
-						convertToApiError(err as AxiosError<RenderErrorResponseDTO>) as APIError,
-					);
-				},
+		deleteDowntimeScheduleAsync(deleteId, {
+			onSuccess: () => {
+				hideDeleteDowntimeScheduleModal();
+				clearSearch();
+				notifications.success({
+					message: 'Downtime schedule Deleted Successfully',
+				});
+				refetchAllSchedules();
 			},
-		);
+			onError: (err) => {
+				showErrorNotification(notifications, err);
+			},
+		});
 	}
 };
 
+export const createEditDowntimeSchedule = async (
+	props: DowntimeScheduleUpdatePayload,
+): Promise<
+	| SuccessResponse<PayloadProps>
+	| ErrorResponse<{ code: string; message: string } | string>
+> => {
+	if (props.id) {
+		return updateDowntimeSchedule({ ...props });
+	}
+	return createDowntimeSchedule({ ...props.data });
+};
+
 export const recurrenceOptions = {
 	doesNotRepeat: {
 		label: 'Does not repeat',
@@ -228,21 +230,19 @@ export const getEndTime = ({
 	kind,
 	schedule,
 }: Partial<
-	RuletypesGettablePlannedMaintenanceDTO & {
+	DowntimeSchedules & {
 		editMode: boolean;
 	}
 >): string | dayjs.Dayjs => {
 	if (kind === 'fixed') {
-		return schedule?.endTime ? dayjs(schedule.endTime).toISOString() : '';
+		return schedule?.endTime || '';
 	}
 
-	return schedule?.recurrence?.endTime
-		? dayjs(schedule.recurrence.endTime).toISOString()
-		: '';
+	return schedule?.recurrence?.endTime || '';
 };
 
 export const isScheduleRecurring = (
-	schedule?: RuletypesGettablePlannedMaintenanceDTO['schedule'] | null,
+	schedule?: DowntimeSchedules['schedule'],
 ): boolean => (schedule ? !isEmpty(schedule?.recurrence) : false);
 
 function convertUtcOffsetToTimezoneOffset(offsetMinutes: number): string {

frontend/src/container/PlannedDowntime/__test__/PlannedDowntime.test.tsx

@@ -1,10 +1,7 @@
 import { UseQueryResult } from 'react-query';
 import { fireEvent, screen } from '@testing-library/react';
-import type {
-	ListDowntimeSchedules200,
-	RenderErrorResponseDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import type { ErrorType } from 'api/generatedAPIInstance';
+import { PayloadProps } from 'api/plannedDowntime/getAllDowntimeSchedules';
+import { AxiosError, AxiosResponse } from 'axios';
 import {
 	mockLocation,
 	mockQueryParams,
@@ -25,53 +22,45 @@ const MOCK_DATE_2 = '2024-01-02';
 const MOCK_DATE_3 = '2024-01-03';
 
 const MOCK_DOWNTIME_1 = createMockDowntime({
-	id: '1',
+	id: 1,
 	name: MOCK_DOWNTIME_1_NAME,
-	createdAt: new Date(MOCK_DATE_1),
-	updatedAt: new Date(MOCK_DATE_1),
-	schedule: buildSchedule({
-		startTime: new Date(MOCK_DATE_1),
-		timezone: 'UTC',
-	}),
+	createdAt: MOCK_DATE_1,
+	updatedAt: MOCK_DATE_1,
+	schedule: buildSchedule({ startTime: MOCK_DATE_1, timezone: 'UTC' }),
 	alertIds: [],
 });
 
 const MOCK_DOWNTIME_2 = createMockDowntime({
-	id: '2',
+	id: 2,
 	name: MOCK_DOWNTIME_2_NAME,
-	createdAt: new Date(MOCK_DATE_2),
-	updatedAt: new Date(MOCK_DATE_2),
-	schedule: buildSchedule({
-		startTime: new Date(MOCK_DATE_2),
-		timezone: 'UTC',
-	}),
+	createdAt: MOCK_DATE_2,
+	updatedAt: MOCK_DATE_2,
+	schedule: buildSchedule({ startTime: MOCK_DATE_2, timezone: 'UTC' }),
 	alertIds: [],
 });
 
 const MOCK_DOWNTIME_3 = createMockDowntime({
-	id: '3',
+	id: 3,
 	name: MOCK_DOWNTIME_3_NAME,
-	createdAt: new Date(MOCK_DATE_3),
-	updatedAt: new Date(MOCK_DATE_3),
-	schedule: buildSchedule({
-		startTime: new Date(MOCK_DATE_3),
-		timezone: 'UTC',
-	}),
+	createdAt: MOCK_DATE_3,
+	updatedAt: MOCK_DATE_3,
+	schedule: buildSchedule({ startTime: MOCK_DATE_3, timezone: 'UTC' }),
 	alertIds: [],
 });
 
-const MOCK_DOWNTIME_RESPONSE: ListDowntimeSchedules200 = {
-	data: [MOCK_DOWNTIME_1, MOCK_DOWNTIME_2, MOCK_DOWNTIME_3],
-	status: 'success',
+const MOCK_DOWNTIME_RESPONSE: Partial<AxiosResponse<PayloadProps>> = {
+	data: {
+		data: [MOCK_DOWNTIME_1, MOCK_DOWNTIME_2, MOCK_DOWNTIME_3],
+	},
 };
 
 type DowntimeQueryResult = UseQueryResult<
-	ListDowntimeSchedules200,
-	ErrorType<RenderErrorResponseDTO>
+	AxiosResponse<PayloadProps>,
+	AxiosError
 >;
 
 const mockDowntimeQueryResult: Partial<DowntimeQueryResult> = {
-	data: MOCK_DOWNTIME_RESPONSE,
+	data: MOCK_DOWNTIME_RESPONSE as AxiosResponse<PayloadProps>,
 	isLoading: false,
 	isFetching: false,
 	isError: false,
@@ -100,27 +89,13 @@ jest.mock('hooks/useSafeNavigate', () => ({
 	}),
 }));
 
-jest.mock('api/generated/services/downtimeschedules', () => ({
-	useListDowntimeSchedules: (): DowntimeQueryResult =>
+jest.mock('api/plannedDowntime/getAllDowntimeSchedules', () => ({
+	useGetAllDowntimeSchedules: (): DowntimeQueryResult =>
 		mockDowntimeQueryResult as DowntimeQueryResult,
-	useDeleteDowntimeScheduleByID: (): {
-		mutateAsync: jest.Mock;
-		isLoading: false;
-	} => ({
-		mutateAsync: jest.fn(),
-		isLoading: false,
-	}),
 }));
-jest.mock('api/generated/services/rules', () => ({
-	useListRules: (): {
-		data: { data: { rules: [] } };
-		isError: false;
-		isLoading: false;
-	} => ({
-		data: { data: { rules: [] } },
-		isError: false,
-		isLoading: false,
-	}),
+jest.mock('api/alerts/getAll', () => ({
+	__esModule: true,
+	default: (): Promise<{ payload: [] }> => Promise.resolve({ payload: [] }),
 }));
 
 describe('PlannedDowntime Component', () => {

frontend/src/container/PlannedDowntime/__test__/testUtils.ts

@@ -1,32 +1,29 @@
-import type {
-	RuletypesGettablePlannedMaintenanceDTO,
-	RuletypesScheduleDTO,
-} from 'api/generated/services/sigNoz.schemas';
+import { DowntimeSchedules } from 'api/plannedDowntime/getAllDowntimeSchedules';
 
 export const buildSchedule = (
-	schedule: Partial<RuletypesScheduleDTO>,
-): RuletypesScheduleDTO => ({
-	timezone: schedule?.timezone ?? '',
-	startTime: schedule?.startTime,
-	endTime: schedule?.endTime,
-	recurrence: schedule?.recurrence,
+	schedule: Partial<DowntimeSchedules['schedule']>,
+): DowntimeSchedules['schedule'] => ({
+	timezone: schedule?.timezone ?? null,
+	startTime: schedule?.startTime ?? null,
+	endTime: schedule?.endTime ?? null,
+	recurrence: schedule?.recurrence ?? null,
 });
 
 export const createMockDowntime = (
-	overrides: Partial<RuletypesGettablePlannedMaintenanceDTO>,
-): RuletypesGettablePlannedMaintenanceDTO => ({
-	id: overrides.id ?? '0',
-	name: overrides.name ?? '',
-	description: overrides.description ?? '',
+	overrides: Partial<DowntimeSchedules>,
+): DowntimeSchedules => ({
+	id: overrides.id ?? 0,
+	name: overrides.name ?? null,
+	description: overrides.description ?? null,
 	schedule: buildSchedule({
 		timezone: 'UTC',
-		startTime: new Date('2024-01-01'),
+		startTime: '2024-01-01',
 		...overrides.schedule,
 	}),
-	alertIds: overrides.alertIds ?? [],
-	createdAt: overrides.createdAt,
-	createdBy: overrides.createdBy ?? '',
-	updatedAt: overrides.updatedAt,
-	updatedBy: overrides.updatedBy ?? '',
-	kind: overrides.kind ?? '',
+	alertIds: overrides.alertIds ?? null,
+	createdAt: overrides.createdAt ?? null,
+	createdBy: overrides.createdBy ?? null,
+	updatedAt: overrides.updatedAt ?? null,
+	updatedBy: overrides.updatedBy ?? null,
+	kind: overrides.kind ?? null,
 });