chore(release): bump to v0.85.2 (#8089)

Co-authored-by: primus-bot[bot] <171087277+primus-bot[bot]@users.noreply.github.com>

.devenv/docker/clickhouse/compose.yaml

@@ -40,7 +40,7 @@ services:
       timeout: 5s
       retries: 3
   schema-migrator-sync:
-    image: signoz/signoz-schema-migrator:v0.111.41
+    image: signoz/signoz-schema-migrator:v0.111.42
     container_name: schema-migrator-sync
     command:
       - sync
@@ -53,7 +53,7 @@ services:
         condition: service_healthy
     restart: on-failure
   schema-migrator-async:
-    image: signoz/signoz-schema-migrator:v0.111.41
+    image: signoz/signoz-schema-migrator:v0.111.42
     container_name: schema-migrator-async
     command:
       - async

.github/CODEOWNERS

@@ -12,3 +12,4 @@
 /pkg/factory/ @grandwizard28
 /pkg/types/ @grandwizard28
 /pkg/sqlmigration/ @vikrantgupta25
+.golangci.yml @grandwizard28

.github/pull_request_template.md

@@ -32,9 +32,7 @@ ex:
 
 > Tag the relevant teams for review:
 
-- [ ] @SigNoz/frontend
-- [ ] @SigNoz/backend
-- [ ] @SigNoz/devops
+- frontend / backend / devops
 
 ---
 

.github/workflows/build-enterprise.yaml

@@ -67,9 +67,8 @@ jobs:
           echo 'TUNNEL_URL="${{ secrets.TUNNEL_URL }}"' >> frontend/.env
           echo 'TUNNEL_DOMAIN="${{ secrets.TUNNEL_DOMAIN }}"' >> frontend/.env
           echo 'POSTHOG_KEY="${{ secrets.POSTHOG_KEY }}"' >> frontend/.env
-          echo 'CUSTOMERIO_ID="${{ secrets.CUSTOMERIO_ID }}"' >> frontend/.env
-          echo 'CUSTOMERIO_SITE_ID="${{ secrets.CUSTOMERIO_SITE_ID }}"' >> frontend/.env
-          echo 'USERPILOT_KEY="${{ secrets.USERPILOT_KEY }}"' >> frontend/.env
+          echo 'PYLON_APP_ID="${{ secrets.PYLON_APP_ID }}"' >> frontend/.env
+          echo 'APPCUES_APP_ID="${{ secrets.APPCUES_APP_ID }}"' >> frontend/.env
       - name: cache-dotenv
         uses: actions/cache@v4
         with:

.github/workflows/build-staging.yaml

@@ -66,7 +66,8 @@ jobs:
           echo 'CI=1' > frontend/.env
           echo 'TUNNEL_URL="${{ secrets.NP_TUNNEL_URL }}"' >> frontend/.env
           echo 'TUNNEL_DOMAIN="${{ secrets.NP_TUNNEL_DOMAIN }}"' >> frontend/.env
-          echo 'USERPILOT_KEY="${{ secrets.NP_USERPILOT_KEY }}"' >> frontend/.env
+          echo 'PYLON_APP_ID="${{ secrets.NP_PYLON_APP_ID }}"' >> frontend/.env
+          echo 'APPCUES_APP_ID="${{ secrets.NP_APPCUES_APP_ID }}"' >> frontend/.env
       - name: cache-dotenv
         uses: actions/cache@v4
         with:

.github/workflows/gor-signoz.yaml

@@ -33,9 +33,8 @@ jobs:
           echo 'TUNNEL_URL="${{ secrets.TUNNEL_URL }}"' >> .env
           echo 'TUNNEL_DOMAIN="${{ secrets.TUNNEL_DOMAIN }}"' >> .env
           echo 'POSTHOG_KEY="${{ secrets.POSTHOG_KEY }}"' >> .env
-          echo 'CUSTOMERIO_ID="${{ secrets.CUSTOMERIO_ID }}"' >> .env
-          echo 'CUSTOMERIO_SITE_ID="${{ secrets.CUSTOMERIO_SITE_ID }}"' >> .env
-          echo 'USERPILOT_KEY="${{ secrets.USERPILOT_KEY }}"' >> .env
+          echo 'PYLON_APP_ID="${{ secrets.PYLON_APP_ID }}"' >> .env
+          echo 'APPCUES_APP_ID="${{ secrets.APPCUES_APP_ID }}"' >> .env
       - name: build-frontend
         run:  make js-build
       - name: upload-frontend-artifact

.golangci.yml

@@ -0,0 +1,33 @@
+linters:
+  default: standard
+  enable:
+    - bodyclose
+    - misspell
+    - nilnil
+    - sloglint
+    - depguard
+    - iface
+
+linters-settings:
+  sloglint:
+    no-mixed-args: true
+    kv-only: true
+    no-global: all
+    context: all
+    static-msg: true
+    msg-style: lowercased
+    key-naming-case: snake
+  depguard:
+    rules:
+      nozap:
+        deny:
+          - pkg: "go.uber.org/zap"
+            desc: "Do not use zap logger. Use slog instead."
+  iface:
+    enable:
+      - identical
+issues:
+  exclude-dirs:
+    - "pkg/query-service"
+    - "ee/query-service"
+    - "scripts/"

conf/example.yaml

@@ -170,3 +170,40 @@ alertmanager:
 analytics:
   # Whether to enable analytics.
   enabled: false
+
+##################### Emailing #####################
+emailing:
+  # Whether to enable emailing.
+  enabled: false
+  templates:
+    # The directory containing the email templates. This directory should contain a list of files defined at pkg/types/emailtypes/template.go.
+    directory: /opt/signoz/conf/templates/email
+  smtp:
+    # The SMTP server address.
+    address: localhost:25
+    # The email address to use for the SMTP server.
+    from:
+    # The hello message to use for the SMTP server.
+    hello:
+    # The static headers to send with the email.
+    headers: {}
+    auth:
+      # The username to use for the SMTP server.
+      username:
+      # The password to use for the SMTP server.
+      password:
+      # The secret to use for the SMTP server.
+      secret:
+      # The identity to use for the SMTP server.
+      identity:
+    tls:
+      # Whether to enable TLS. It should be false in most cases since the authentication mechanism should use the STARTTLS extension instead.
+      enabled: false
+      # Whether to skip TLS verification.
+      insecure_skip_verify: false
+      # The path to the CA file.
+      ca_file_path:
+      # The path to the key file.
+      key_file_path:
+      # The path to the certificate file.
+      cert_file_path:

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

@@ -174,7 +174,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.83.0
+    image: signoz/signoz:v0.85.2
     command:
       - --config=/root/config/prometheus.yml
     ports:
@@ -206,7 +206,7 @@ services:
       retries: 3
   otel-collector:
     !!merge <<: *db-depend
-    image: signoz/signoz-otel-collector:v0.111.41
+    image: signoz/signoz-otel-collector:v0.111.42
     command:
       - --config=/etc/otel-collector-config.yaml
       - --manager-config=/etc/manager-config.yaml
@@ -230,7 +230,7 @@ services:
       - signoz
   schema-migrator:
     !!merge <<: *common
-    image: signoz/signoz-schema-migrator:v0.111.41
+    image: signoz/signoz-schema-migrator:v0.111.42
     deploy:
       restart_policy:
         condition: on-failure

deploy/docker-swarm/docker-compose.yaml

@@ -110,7 +110,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.83.0
+    image: signoz/signoz:v0.85.2
     command:
       - --config=/root/config/prometheus.yml
     ports:
@@ -141,7 +141,7 @@ services:
       retries: 3
   otel-collector:
     !!merge <<: *db-depend
-    image: signoz/signoz-otel-collector:v0.111.41
+    image: signoz/signoz-otel-collector:v0.111.42
     command:
       - --config=/etc/otel-collector-config.yaml
       - --manager-config=/etc/manager-config.yaml
@@ -165,7 +165,7 @@ services:
       - signoz
   schema-migrator:
     !!merge <<: *common
-    image: signoz/signoz-schema-migrator:v0.111.41
+    image: signoz/signoz-schema-migrator:v0.111.42
     deploy:
       restart_policy:
         condition: on-failure

deploy/docker/docker-compose.ha.yaml

@@ -177,7 +177,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.83.0}
+    image: signoz/signoz:${VERSION:-v0.85.2}
     container_name: signoz
     command:
       - --config=/root/config/prometheus.yml
@@ -210,7 +210,7 @@ services:
   # TODO: support otel-collector multiple replicas. Nginx/Traefik for loadbalancing?
   otel-collector:
     !!merge <<: *db-depend
-    image: signoz/signoz-otel-collector:${OTELCOL_TAG:-v0.111.41}
+    image: signoz/signoz-otel-collector:${OTELCOL_TAG:-v0.111.42}
     container_name: signoz-otel-collector
     command:
       - --config=/etc/otel-collector-config.yaml
@@ -236,7 +236,7 @@ services:
         condition: service_healthy
   schema-migrator-sync:
     !!merge <<: *common
-    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.111.41}
+    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.111.42}
     container_name: schema-migrator-sync
     command:
       - sync
@@ -247,7 +247,7 @@ services:
         condition: service_healthy
   schema-migrator-async:
     !!merge <<: *db-depend
-    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.111.41}
+    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.111.42}
     container_name: schema-migrator-async
     command:
       - async

deploy/docker/docker-compose.yaml

@@ -110,7 +110,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.83.0}
+    image: signoz/signoz:${VERSION:-v0.85.2}
     container_name: signoz
     command:
       - --config=/root/config/prometheus.yml
@@ -142,7 +142,7 @@ services:
       retries: 3
   otel-collector:
     !!merge <<: *db-depend
-    image: signoz/signoz-otel-collector:${OTELCOL_TAG:-v0.111.41}
+    image: signoz/signoz-otel-collector:${OTELCOL_TAG:-v0.111.42}
     container_name: signoz-otel-collector
     command:
       - --config=/etc/otel-collector-config.yaml
@@ -164,7 +164,7 @@ services:
         condition: service_healthy
   schema-migrator-sync:
     !!merge <<: *common
-    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.111.41}
+    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.111.42}
     container_name: schema-migrator-sync
     command:
       - sync
@@ -176,7 +176,7 @@ services:
     restart: on-failure
   schema-migrator-async:
     !!merge <<: *db-depend
-    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.111.41}
+    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.111.42}
     container_name: schema-migrator-async
     command:
       - async

ee/http/middleware/pat.go

@@ -1,91 +0,0 @@
-package middleware
-
-import (
-	"net/http"
-	"time"
-
-	eeTypes "github.com/SigNoz/signoz/ee/types"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"go.uber.org/zap"
-)
-
-type Pat struct {
-	store   sqlstore.SQLStore
-	uuid    *authtypes.UUID
-	headers []string
-}
-
-func NewPat(store sqlstore.SQLStore, headers []string) *Pat {
-	return &Pat{store: store, uuid: authtypes.NewUUID(), headers: headers}
-}
-
-func (p *Pat) Wrap(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		var values []string
-		var patToken string
-		var pat eeTypes.StorablePersonalAccessToken
-
-		for _, header := range p.headers {
-			values = append(values, r.Header.Get(header))
-		}
-
-		ctx, err := p.uuid.ContextFromRequest(r.Context(), values...)
-		if err != nil {
-			next.ServeHTTP(w, r)
-			return
-		}
-		patToken, ok := authtypes.UUIDFromContext(ctx)
-		if !ok {
-			next.ServeHTTP(w, r)
-			return
-		}
-
-		err = p.store.BunDB().NewSelect().Model(&pat).Where("token = ?", patToken).Scan(r.Context())
-		if err != nil {
-			next.ServeHTTP(w, r)
-			return
-		}
-
-		if pat.ExpiresAt < time.Now().Unix() && pat.ExpiresAt != 0 {
-			next.ServeHTTP(w, r)
-			return
-		}
-
-		// get user from db
-		user := types.User{}
-		err = p.store.BunDB().NewSelect().Model(&user).Where("id = ?", pat.UserID).Scan(r.Context())
-		if err != nil {
-			next.ServeHTTP(w, r)
-			return
-		}
-
-		role, err := types.NewRole(user.Role)
-		if err != nil {
-			next.ServeHTTP(w, r)
-			return
-		}
-
-		jwt := authtypes.Claims{
-			UserID: user.ID.String(),
-			Role:   role,
-			Email:  user.Email,
-			OrgID:  user.OrgID,
-		}
-
-		ctx = authtypes.NewContextWithClaims(ctx, jwt)
-
-		r = r.WithContext(ctx)
-
-		next.ServeHTTP(w, r)
-
-		pat.LastUsed = time.Now().Unix()
-		_, err = p.store.BunDB().NewUpdate().Model(&pat).Column("last_used").Where("token = ?", patToken).Where("revoked = false").Exec(r.Context())
-		if err != nil {
-			zap.L().Error("Failed to update PAT last used in db, err: %v", zap.Error(err))
-		}
-
-	})
-
-}

ee/licensing/config.go

@@ -0,0 +1,26 @@
+package licensing
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/licensing"
+)
+
+var (
+	config licensing.Config
+	once   sync.Once
+)
+
+// initializes the licensing configuration
+func Config(pollInterval time.Duration, failureThreshold int) licensing.Config {
+	once.Do(func() {
+		config = licensing.Config{PollInterval: pollInterval, FailureThreshold: failureThreshold}
+		if err := config.Validate(); err != nil {
+			panic(fmt.Errorf("invalid licensing config: %w", err))
+		}
+	})
+
+	return config
+}

ee/licensing/httplicensing/api.go

@@ -0,0 +1,168 @@
+package httplicensing
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/SigNoz/signoz/pkg/licensing"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/licensetypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type licensingAPI struct {
+	licensing licensing.Licensing
+}
+
+func NewLicensingAPI(licensing licensing.Licensing) licensing.API {
+	return &licensingAPI{licensing: licensing}
+}
+
+func (api *licensingAPI) Activate(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "orgId is invalid"))
+		return
+	}
+
+	req := new(licensetypes.PostableLicense)
+	err = json.NewDecoder(r.Body).Decode(&req)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	err = api.licensing.Activate(r.Context(), orgID, req.Key)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusAccepted, nil)
+}
+
+func (api *licensingAPI) GetActive(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "orgId is invalid"))
+		return
+	}
+
+	license, err := api.licensing.GetActive(r.Context(), orgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	gettableLicense := licensetypes.NewGettableLicense(license.Data, license.Key)
+	render.Success(rw, http.StatusOK, gettableLicense)
+}
+
+func (api *licensingAPI) Refresh(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "orgId is invalid"))
+		return
+	}
+
+	err = api.licensing.Refresh(r.Context(), orgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusNoContent, nil)
+}
+
+func (api *licensingAPI) Checkout(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "orgId is invalid"))
+		return
+	}
+
+	req := new(licensetypes.PostableSubscription)
+	if err := json.NewDecoder(r.Body).Decode(req); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	gettableSubscription, err := api.licensing.Checkout(ctx, orgID, req)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusCreated, gettableSubscription)
+}
+
+func (api *licensingAPI) Portal(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "orgId is invalid"))
+		return
+	}
+
+	req := new(licensetypes.PostableSubscription)
+	if err := json.NewDecoder(r.Body).Decode(req); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	gettableSubscription, err := api.licensing.Portal(ctx, orgID, req)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusCreated, gettableSubscription)
+}

ee/licensing/httplicensing/provider.go

@@ -0,0 +1,280 @@
+package httplicensing
+
+import (
+	"context"
+	"encoding/json"
+	"time"
+
+	"github.com/SigNoz/signoz/ee/licensing/licensingstore/sqllicensingstore"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/licensing"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/types/featuretypes"
+	"github.com/SigNoz/signoz/pkg/types/licensetypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/SigNoz/signoz/pkg/zeus"
+	"github.com/tidwall/gjson"
+)
+
+type provider struct {
+	store    licensetypes.Store
+	zeus     zeus.Zeus
+	config   licensing.Config
+	settings factory.ScopedProviderSettings
+	stopChan chan struct{}
+}
+
+func NewProviderFactory(store sqlstore.SQLStore, zeus zeus.Zeus) factory.ProviderFactory[licensing.Licensing, licensing.Config] {
+	return factory.NewProviderFactory(factory.MustNewName("http"), func(ctx context.Context, providerSettings factory.ProviderSettings, config licensing.Config) (licensing.Licensing, error) {
+		return New(ctx, providerSettings, config, store, zeus)
+	})
+}
+
+func New(ctx context.Context, ps factory.ProviderSettings, config licensing.Config, sqlstore sqlstore.SQLStore, zeus zeus.Zeus) (licensing.Licensing, error) {
+	settings := factory.NewScopedProviderSettings(ps, "github.com/SigNoz/signoz/ee/licensing/httplicensing")
+	licensestore := sqllicensingstore.New(sqlstore)
+	return &provider{store: licensestore, zeus: zeus, config: config, settings: settings, stopChan: make(chan struct{})}, nil
+}
+
+func (provider *provider) Start(ctx context.Context) error {
+	tick := time.NewTicker(provider.config.PollInterval)
+	defer tick.Stop()
+
+	err := provider.Validate(ctx)
+	if err != nil {
+		provider.settings.Logger().ErrorContext(ctx, "failed to validate license from upstream server", "error", err)
+	}
+
+	for {
+		select {
+		case <-provider.stopChan:
+			return nil
+		case <-tick.C:
+			err := provider.Validate(ctx)
+			if err != nil {
+				provider.settings.Logger().ErrorContext(ctx, "failed to validate license from upstream server", "error", err)
+			}
+		}
+	}
+}
+
+func (provider *provider) Stop(ctx context.Context) error {
+	provider.settings.Logger().DebugContext(ctx, "license validation stopped")
+	close(provider.stopChan)
+	return nil
+}
+
+func (provider *provider) Validate(ctx context.Context) error {
+	organizations, err := provider.store.ListOrganizations(ctx)
+	if err != nil {
+		return err
+	}
+
+	for _, organizationID := range organizations {
+		err := provider.Refresh(ctx, organizationID)
+		if err != nil {
+			return err
+		}
+	}
+
+	if len(organizations) == 0 {
+		err = provider.InitFeatures(ctx, licensetypes.BasicPlan)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (provider *provider) Activate(ctx context.Context, organizationID valuer.UUID, key string) error {
+	data, err := provider.zeus.GetLicense(ctx, key)
+	if err != nil {
+		return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "unable to fetch license data with upstream server")
+	}
+
+	license, err := licensetypes.NewLicense(data, organizationID)
+	if err != nil {
+		return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to create license entity")
+	}
+
+	storableLicense := licensetypes.NewStorableLicenseFromLicense(license)
+	err = provider.store.Create(ctx, storableLicense)
+	if err != nil {
+		return err
+	}
+
+	err = provider.InitFeatures(ctx, license.Features)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (provider *provider) GetActive(ctx context.Context, organizationID valuer.UUID) (*licensetypes.License, error) {
+	storableLicenses, err := provider.store.GetAll(ctx, organizationID)
+	if err != nil {
+		return nil, err
+	}
+
+	activeLicense, err := licensetypes.GetActiveLicenseFromStorableLicenses(storableLicenses, organizationID)
+	if err != nil {
+		return nil, err
+	}
+
+	return activeLicense, nil
+}
+
+func (provider *provider) Refresh(ctx context.Context, organizationID valuer.UUID) error {
+	activeLicense, err := provider.GetActive(ctx, organizationID)
+	if err != nil && !errors.Ast(err, errors.TypeNotFound) {
+		provider.settings.Logger().ErrorContext(ctx, "license validation failed", "org_id", organizationID.StringValue())
+		return err
+	}
+
+	if err != nil && errors.Ast(err, errors.TypeNotFound) {
+		provider.settings.Logger().DebugContext(ctx, "no active license found, defaulting to basic plan", "org_id", organizationID.StringValue())
+		err = provider.InitFeatures(ctx, licensetypes.BasicPlan)
+		if err != nil {
+			return err
+		}
+		return nil
+	}
+
+	data, err := provider.zeus.GetLicense(ctx, activeLicense.Key)
+	if err != nil {
+		if time.Since(activeLicense.LastValidatedAt) > time.Duration(provider.config.FailureThreshold)*provider.config.PollInterval {
+			provider.settings.Logger().ErrorContext(ctx, "license validation failed for consecutive poll intervals, defaulting to basic plan", "failure_threshold", provider.config.FailureThreshold, "license_id", activeLicense.ID.StringValue(), "org_id", organizationID.StringValue())
+			err = provider.InitFeatures(ctx, licensetypes.BasicPlan)
+			if err != nil {
+				return err
+			}
+			return nil
+		}
+		return err
+	}
+
+	err = activeLicense.Update(data)
+	if err != nil {
+		return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to create license entity from license data")
+	}
+
+	updatedStorableLicense := licensetypes.NewStorableLicenseFromLicense(activeLicense)
+	err = provider.store.Update(ctx, organizationID, updatedStorableLicense)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (provider *provider) Checkout(ctx context.Context, organizationID valuer.UUID, postableSubscription *licensetypes.PostableSubscription) (*licensetypes.GettableSubscription, error) {
+	activeLicense, err := provider.GetActive(ctx, organizationID)
+	if err != nil {
+		return nil, err
+	}
+
+	body, err := json.Marshal(postableSubscription)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to marshal checkout payload")
+	}
+
+	response, err := provider.zeus.GetCheckoutURL(ctx, activeLicense.Key, body)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to generate checkout session")
+	}
+
+	return &licensetypes.GettableSubscription{RedirectURL: gjson.GetBytes(response, "url").String()}, nil
+}
+
+func (provider *provider) Portal(ctx context.Context, organizationID valuer.UUID, postableSubscription *licensetypes.PostableSubscription) (*licensetypes.GettableSubscription, error) {
+	activeLicense, err := provider.GetActive(ctx, organizationID)
+	if err != nil {
+		return nil, err
+	}
+
+	body, err := json.Marshal(postableSubscription)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to marshal portal payload")
+	}
+
+	response, err := provider.zeus.GetPortalURL(ctx, activeLicense.Key, body)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to generate portal session")
+	}
+
+	return &licensetypes.GettableSubscription{RedirectURL: gjson.GetBytes(response, "url").String()}, nil
+}
+
+// feature surrogate
+func (provider *provider) CheckFeature(ctx context.Context, key string) error {
+	feature, err := provider.store.GetFeature(ctx, key)
+	if err != nil {
+		return err
+	}
+	if feature.Active {
+		return nil
+	}
+	return errors.Newf(errors.TypeUnsupported, licensing.ErrCodeFeatureUnavailable, "feature unavailable: %s", key)
+}
+
+func (provider *provider) GetFeatureFlag(ctx context.Context, key string) (*featuretypes.GettableFeature, error) {
+	featureStatus, err := provider.store.GetFeature(ctx, key)
+	if err != nil {
+		return nil, err
+	}
+	return &featuretypes.GettableFeature{
+		Name:       featureStatus.Name,
+		Active:     featureStatus.Active,
+		Usage:      int64(featureStatus.Usage),
+		UsageLimit: int64(featureStatus.UsageLimit),
+		Route:      featureStatus.Route,
+	}, nil
+}
+
+func (provider *provider) GetFeatureFlags(ctx context.Context) ([]*featuretypes.GettableFeature, error) {
+	storableFeatures, err := provider.store.GetAllFeatures(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	gettableFeatures := make([]*featuretypes.GettableFeature, len(storableFeatures))
+	for idx, gettableFeature := range storableFeatures {
+		gettableFeatures[idx] = &featuretypes.GettableFeature{
+			Name:       gettableFeature.Name,
+			Active:     gettableFeature.Active,
+			Usage:      int64(gettableFeature.Usage),
+			UsageLimit: int64(gettableFeature.UsageLimit),
+			Route:      gettableFeature.Route,
+		}
+	}
+
+	return gettableFeatures, nil
+}
+
+func (provider *provider) InitFeatures(ctx context.Context, features []*featuretypes.GettableFeature) error {
+	featureStatus := make([]*featuretypes.StorableFeature, len(features))
+	for i, f := range features {
+		featureStatus[i] = &featuretypes.StorableFeature{
+			Name:       f.Name,
+			Active:     f.Active,
+			Usage:      int(f.Usage),
+			UsageLimit: int(f.UsageLimit),
+			Route:      f.Route,
+		}
+	}
+
+	return provider.store.InitFeatures(ctx, featureStatus)
+}
+
+func (provider *provider) UpdateFeatureFlag(ctx context.Context, feature *featuretypes.GettableFeature) error {
+	return provider.store.UpdateFeature(ctx, &featuretypes.StorableFeature{
+		Name:       feature.Name,
+		Active:     feature.Active,
+		Usage:      int(feature.Usage),
+		UsageLimit: int(feature.UsageLimit),
+		Route:      feature.Route,
+	})
+}

ee/licensing/licensingstore/sqllicensingstore/store.go

@@ -0,0 +1,186 @@
+package sqllicensingstore
+
+import (
+	"context"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/featuretypes"
+	"github.com/SigNoz/signoz/pkg/types/licensetypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type store struct {
+	sqlstore sqlstore.SQLStore
+}
+
+func New(sqlstore sqlstore.SQLStore) licensetypes.Store {
+	return &store{sqlstore}
+}
+
+func (store *store) Create(ctx context.Context, storableLicense *licensetypes.StorableLicense) error {
+	_, err := store.
+		sqlstore.
+		BunDB().
+		NewInsert().
+		Model(storableLicense).
+		Exec(ctx)
+	if err != nil {
+		return store.sqlstore.WrapAlreadyExistsErrf(err, errors.CodeAlreadyExists, "license with ID: %s already exists", storableLicense.ID)
+	}
+
+	return nil
+}
+
+func (store *store) Get(ctx context.Context, organizationID valuer.UUID, licenseID valuer.UUID) (*licensetypes.StorableLicense, error) {
+	storableLicense := new(licensetypes.StorableLicense)
+	err := store.
+		sqlstore.
+		BunDB().
+		NewSelect().
+		Model(storableLicense).
+		Where("org_id = ?", organizationID).
+		Where("id = ?", licenseID).
+		Scan(ctx)
+	if err != nil {
+		return nil, store.sqlstore.WrapNotFoundErrf(err, errors.CodeNotFound, "license with ID: %s does not exist", licenseID)
+	}
+
+	return storableLicense, nil
+}
+
+func (store *store) GetAll(ctx context.Context, organizationID valuer.UUID) ([]*licensetypes.StorableLicense, error) {
+	storableLicenses := make([]*licensetypes.StorableLicense, 0)
+	err := store.
+		sqlstore.
+		BunDB().
+		NewSelect().
+		Model(&storableLicenses).
+		Where("org_id = ?", organizationID).
+		Scan(ctx)
+	if err != nil {
+		return nil, store.sqlstore.WrapNotFoundErrf(err, errors.CodeNotFound, "licenses for organizationID: %s does not exists", organizationID)
+	}
+
+	return storableLicenses, nil
+}
+
+func (store *store) Update(ctx context.Context, organizationID valuer.UUID, storableLicense *licensetypes.StorableLicense) error {
+	_, err := store.
+		sqlstore.
+		BunDB().
+		NewUpdate().
+		Model(storableLicense).
+		WherePK().
+		Where("org_id = ?", organizationID).
+		Exec(ctx)
+	if err != nil {
+		return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "unable to update license with ID: %s", storableLicense.ID)
+	}
+
+	return nil
+}
+
+func (store *store) ListOrganizations(ctx context.Context) ([]valuer.UUID, error) {
+	orgIDStrs := make([]string, 0)
+	err := store.sqlstore.
+		BunDB().
+		NewSelect().
+		Model(new(types.Organization)).
+		Column("id").
+		Scan(ctx, &orgIDStrs)
+	if err != nil {
+		return nil, err
+	}
+
+	orgIDs := make([]valuer.UUID, len(orgIDStrs))
+	for idx, orgIDStr := range orgIDStrs {
+		orgID, err := valuer.NewUUID(orgIDStr)
+		if err != nil {
+			return nil, err
+		}
+		orgIDs[idx] = orgID
+	}
+
+	return orgIDs, nil
+
+}
+
+func (store *store) CreateFeature(ctx context.Context, storableFeature *featuretypes.StorableFeature) error {
+	_, err := store.
+		sqlstore.
+		BunDB().
+		NewInsert().
+		Model(storableFeature).
+		Exec(ctx)
+	if err != nil {
+		return store.sqlstore.WrapAlreadyExistsErrf(err, errors.CodeAlreadyExists, "feature with name:%s already exists", storableFeature.Name)
+	}
+
+	return nil
+}
+
+func (store *store) GetFeature(ctx context.Context, key string) (*featuretypes.StorableFeature, error) {
+	storableFeature := new(featuretypes.StorableFeature)
+	err := store.
+		sqlstore.
+		BunDB().
+		NewSelect().
+		Model(storableFeature).
+		Where("name = ?", key).
+		Scan(ctx)
+	if err != nil {
+		return nil, store.sqlstore.WrapNotFoundErrf(err, errors.CodeNotFound, "feature with name:%s does not exist", key)
+	}
+
+	return storableFeature, nil
+}
+
+func (store *store) GetAllFeatures(ctx context.Context) ([]*featuretypes.StorableFeature, error) {
+	storableFeatures := make([]*featuretypes.StorableFeature, 0)
+	err := store.
+		sqlstore.
+		BunDB().
+		NewSelect().
+		Model(&storableFeatures).
+		Scan(ctx)
+	if err != nil {
+		return nil, store.sqlstore.WrapNotFoundErrf(err, errors.CodeNotFound, "features do not exist")
+	}
+
+	return storableFeatures, nil
+}
+
+func (store *store) InitFeatures(ctx context.Context, storableFeatures []*featuretypes.StorableFeature) error {
+	_, err := store.
+		sqlstore.
+		BunDB().
+		NewInsert().
+		Model(&storableFeatures).
+		On("CONFLICT (name) DO UPDATE").
+		Set("active = EXCLUDED.active").
+		Set("usage = EXCLUDED.usage").
+		Set("usage_limit = EXCLUDED.usage_limit").
+		Set("route = EXCLUDED.route").
+		Exec(ctx)
+	if err != nil {
+		return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "unable to initialise features")
+	}
+
+	return nil
+}
+
+func (store *store) UpdateFeature(ctx context.Context, storableFeature *featuretypes.StorableFeature) error {
+	_, err := store.
+		sqlstore.
+		BunDB().
+		NewUpdate().
+		Model(storableFeature).
+		Exec(ctx)
+	if err != nil {
+		return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "unable to update feature with key: %s", storableFeature.Name)
+	}
+
+	return nil
+}

ee/modules/user/impluser/handler.go

@@ -1,203 +0,0 @@
-package impluser
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/modules/user"
-	"github.com/SigNoz/signoz/pkg/modules/user/impluser"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/gorilla/mux"
-)
-
-// EnterpriseHandler embeds the base handler implementation
-type Handler struct {
-	user.Handler // Embed the base handler interface
-	module       user.Module
-}
-
-func NewHandler(module user.Module) user.Handler {
-	baseHandler := impluser.NewHandler(module)
-	return &Handler{
-		Handler: baseHandler,
-		module:  module,
-	}
-}
-
-func (h *Handler) Login(w http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	var req types.PostableLoginRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	if req.RefreshToken == "" {
-		// the EE handler wrapper passes the feature flag value in context
-		ssoAvailable, ok := ctx.Value(types.SSOAvailable).(bool)
-		if !ok {
-			render.Error(w, errors.New(errors.TypeInternal, errors.CodeInternal, "failed to retrieve SSO availability"))
-			return
-		}
-
-		if ssoAvailable {
-			_, err := h.module.CanUsePassword(ctx, req.Email)
-			if err != nil {
-				render.Error(w, err)
-				return
-			}
-		}
-	}
-
-	user, err := h.module.GetAuthenticatedUser(ctx, req.OrgID, req.Email, req.Password, req.RefreshToken)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	jwt, err := h.module.GetJWTForUser(ctx, user)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	gettableLoginResponse := &types.GettableLoginResponse{
-		GettableUserJwt: jwt,
-		UserID:          user.ID.String(),
-	}
-
-	render.Success(w, http.StatusOK, gettableLoginResponse)
-}
-
-// Override only the methods you need with enterprise-specific implementations
-func (h *Handler) LoginPrecheck(w http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	// assume user is valid unless proven otherwise and assign default values for rest of the fields
-
-	email := r.URL.Query().Get("email")
-	sourceUrl := r.URL.Query().Get("ref")
-	orgID := r.URL.Query().Get("orgID")
-
-	resp, err := h.module.LoginPrecheck(ctx, orgID, email, sourceUrl)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	render.Success(w, http.StatusOK, resp)
-
-}
-
-func (h *Handler) AcceptInvite(w http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	req := new(types.PostableAcceptInvite)
-	if err := json.NewDecoder(r.Body).Decode(req); err != nil {
-		render.Error(w, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to decode user"))
-		return
-	}
-
-	// get invite object
-	invite, err := h.module.GetInviteByToken(ctx, req.InviteToken)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	orgDomain, err := h.module.GetAuthDomainByEmail(ctx, invite.Email)
-	if err != nil && !errors.Ast(err, errors.TypeNotFound) {
-		render.Error(w, err)
-		return
-	}
-
-	precheckResp := &types.GettableLoginPrecheck{
-		SSO:    false,
-		IsUser: false,
-	}
-
-	if invite.Name == "" && req.DisplayName != "" {
-		invite.Name = req.DisplayName
-	}
-
-	user, err := types.NewUser(invite.Name, invite.Email, invite.Role, invite.OrgID)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	if orgDomain != nil && orgDomain.SsoEnabled {
-		// sso is enabled, create user and respond precheck data
-		err = h.module.CreateUser(ctx, user)
-		if err != nil {
-			render.Error(w, err)
-			return
-		}
-
-		// check if sso is enforced for the org
-		precheckResp, err = h.module.LoginPrecheck(ctx, invite.OrgID, user.Email, req.SourceURL)
-		if err != nil {
-			render.Error(w, err)
-			return
-		}
-
-	} else {
-		password, err := types.NewFactorPassword(req.Password)
-		if err != nil {
-			render.Error(w, err)
-			return
-		}
-
-		user, err = h.module.CreateUserWithPassword(ctx, user, password)
-		if err != nil {
-			render.Error(w, err)
-			return
-		}
-
-		precheckResp.IsUser = true
-	}
-
-	// delete the invite
-	if err := h.module.DeleteInvite(ctx, invite.OrgID, invite.ID); err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	render.Success(w, http.StatusOK, precheckResp)
-}
-
-func (h *Handler) GetInvite(w http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	token := mux.Vars(r)["token"]
-	sourceUrl := r.URL.Query().Get("ref")
-	invite, err := h.module.GetInviteByToken(ctx, token)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	// precheck the user
-	precheckResp, err := h.module.LoginPrecheck(ctx, invite.OrgID, invite.Email, sourceUrl)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	gettableInvite := &types.GettableEEInvite{
-		GettableInvite: *invite,
-		PreCheck:       precheckResp,
-	}
-
-	render.Success(w, http.StatusOK, gettableInvite)
-	return
-}

ee/modules/user/impluser/module.go

@@ -1,229 +0,0 @@
-package impluser
-
-import (
-	"context"
-	"fmt"
-	"net/url"
-	"strings"
-
-	"github.com/SigNoz/signoz/ee/query-service/constants"
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/modules/user"
-	baseimpl "github.com/SigNoz/signoz/pkg/modules/user/impluser"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"go.uber.org/zap"
-)
-
-// EnterpriseModule embeds the base module implementation
-type Module struct {
-	*baseimpl.Module // Embed the base module implementation
-	store            types.UserStore
-}
-
-func NewModule(store types.UserStore) user.Module {
-	baseModule := baseimpl.NewModule(store).(*baseimpl.Module)
-	return &Module{
-		Module: baseModule,
-		store:  store,
-	}
-}
-
-func (m *Module) createUserForSAMLRequest(ctx context.Context, email string) (*types.User, error) {
-	// get auth domain from email domain
-	_, err := m.GetAuthDomainByEmail(ctx, email)
-	if err != nil && !errors.Ast(err, errors.TypeNotFound) {
-		return nil, err
-	}
-
-	// get name from email
-	parts := strings.Split(email, "@")
-	if len(parts) < 2 {
-		return nil, errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid email format")
-	}
-	name := parts[0]
-
-	defaultOrgID, err := m.store.GetDefaultOrgID(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	user, err := types.NewUser(name, email, types.RoleViewer.String(), defaultOrgID)
-	if err != nil {
-		return nil, err
-	}
-
-	err = m.CreateUser(ctx, user)
-	if err != nil {
-		return nil, err
-	}
-
-	return user, nil
-}
-
-func (m *Module) PrepareSsoRedirect(ctx context.Context, redirectUri, email string, jwt *authtypes.JWT) (string, error) {
-	users, err := m.GetUsersByEmail(ctx, email)
-	if err != nil {
-		zap.L().Error("failed to get user with email received from auth provider", zap.String("error", err.Error()))
-		return "", err
-	}
-	user := &types.User{}
-
-	if len(users) == 0 {
-		newUser, err := m.createUserForSAMLRequest(ctx, email)
-		user = newUser
-		if err != nil {
-			zap.L().Error("failed to create user with email received from auth provider", zap.Error(err))
-			return "", err
-		}
-	} else {
-		user = &users[0].User
-	}
-
-	tokenStore, err := m.GetJWTForUser(ctx, user)
-	if err != nil {
-		zap.L().Error("failed to generate token for SSO login user", zap.Error(err))
-		return "", err
-	}
-
-	return fmt.Sprintf("%s?jwt=%s&usr=%s&refreshjwt=%s",
-		redirectUri,
-		tokenStore.AccessJwt,
-		user.ID,
-		tokenStore.RefreshJwt), nil
-}
-
-func (m *Module) CanUsePassword(ctx context.Context, email string) (bool, error) {
-	domain, err := m.GetAuthDomainByEmail(ctx, email)
-	if err != nil && !errors.Ast(err, errors.TypeNotFound) {
-		return false, err
-	}
-
-	if domain != nil && domain.SsoEnabled {
-		// sso is enabled, check if the user has admin role
-		users, err := m.GetUsersByEmail(ctx, email)
-		if err != nil {
-			return false, err
-		}
-
-		if len(users) == 0 {
-			return false, errors.New(errors.TypeNotFound, errors.CodeNotFound, "user not found")
-		}
-
-		if users[0].Role != types.RoleAdmin.String() {
-			return false, errors.New(errors.TypeForbidden, errors.CodeForbidden, "auth method not supported")
-		}
-
-	}
-
-	return true, nil
-}
-
-func (m *Module) LoginPrecheck(ctx context.Context, orgID, email, sourceUrl string) (*types.GettableLoginPrecheck, error) {
-	resp := &types.GettableLoginPrecheck{IsUser: true, CanSelfRegister: false}
-
-	// check if email is a valid user
-	users, err := m.GetUsersByEmail(ctx, email)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(users) == 0 {
-		resp.IsUser = false
-	}
-
-	// give them an option to select an org
-	if orgID == "" && len(users) > 1 {
-		resp.SelectOrg = true
-		resp.Orgs = make([]string, len(users))
-		for i, user := range users {
-			resp.Orgs[i] = user.OrgID
-		}
-		return resp, nil
-	}
-
-	// select the user with the corresponding orgID
-	if len(users) > 1 {
-		found := false
-		for _, tuser := range users {
-			if tuser.OrgID == orgID {
-				// user = tuser
-				found = true
-				break
-			}
-		}
-		if !found {
-			resp.IsUser = false
-			return resp, nil
-		}
-	}
-
-	// the EE handler wrapper passes the feature flag value in context
-	ssoAvailable, ok := ctx.Value(types.SSOAvailable).(bool)
-	if !ok {
-		zap.L().Error("failed to retrieve ssoAvailable from context")
-		return nil, errors.New(errors.TypeInternal, errors.CodeInternal, "failed to retrieve SSO availability")
-	}
-
-	if ssoAvailable {
-
-		// TODO(Nitya): in multitenancy this should use orgId as well.
-		orgDomain, err := m.GetAuthDomainByEmail(ctx, email)
-		if err != nil && !errors.Ast(err, errors.TypeNotFound) {
-			return nil, err
-		}
-
-		if orgDomain != nil && orgDomain.SsoEnabled {
-			// this is to allow self registration
-			resp.IsUser = true
-
-			// saml is enabled for this domain, lets prepare sso url
-			if sourceUrl == "" {
-				sourceUrl = constants.GetDefaultSiteURL()
-			}
-
-			// parse source url that generated the login request
-			var err error
-			escapedUrl, _ := url.QueryUnescape(sourceUrl)
-			siteUrl, err := url.Parse(escapedUrl)
-			if err != nil {
-				return nil, errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to parse referer")
-			}
-
-			// build Idp URL that will authenticat the user
-			// the front-end will redirect user to this url
-			resp.SSOUrl, err = orgDomain.BuildSsoUrl(siteUrl)
-			if err != nil {
-				zap.L().Error("failed to prepare saml request for domain", zap.String("domain", orgDomain.Name), zap.Error(err))
-				return nil, errors.New(errors.TypeInternal, errors.CodeInternal, "failed to prepare saml request for domain")
-			}
-
-			// set SSO to true, as the url is generated correctly
-			resp.SSO = true
-		}
-	}
-	return resp, nil
-}
-
-func (m *Module) GetAuthDomainByEmail(ctx context.Context, email string) (*types.GettableOrgDomain, error) {
-
-	if email == "" {
-		return nil, errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "email is required")
-	}
-
-	components := strings.Split(email, "@")
-	if len(components) < 2 {
-		return nil, errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid email format")
-	}
-
-	domain, err := m.store.GetDomainByName(ctx, components[1])
-	if err != nil {
-		return nil, err
-	}
-
-	gettableDomain := &types.GettableOrgDomain{StorableOrgDomain: *domain}
-	if err := gettableDomain.LoadConfig(domain.Data); err != nil {
-		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to load domain config")
-	}
-	return gettableDomain, nil
-}

ee/modules/user/impluser/store.go

@@ -1,37 +0,0 @@
-package impluser
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	baseimpl "github.com/SigNoz/signoz/pkg/modules/user/impluser"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/types"
-)
-
-type store struct {
-	*baseimpl.Store
-	sqlstore sqlstore.SQLStore
-}
-
-func NewStore(sqlstore sqlstore.SQLStore) types.UserStore {
-	baseStore := baseimpl.NewStore(sqlstore).(*baseimpl.Store)
-	return &store{
-		Store:    baseStore,
-		sqlstore: sqlstore,
-	}
-}
-
-func (s *store) GetDomainByName(ctx context.Context, name string) (*types.StorableOrgDomain, error) {
-	domain := new(types.StorableOrgDomain)
-	err := s.sqlstore.BunDB().NewSelect().
-		Model(domain).
-		Where("name = ?", name).
-		Limit(1).
-		Scan(ctx)
-
-	if err != nil {
-		return nil, errors.Wrapf(err, errors.TypeNotFound, errors.CodeNotFound, "failed to get domain from name")
-	}
-	return domain, nil
-}

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

@@ -6,42 +6,30 @@ import (
 	"net/http/httputil"
 	"time"
 
-	"github.com/SigNoz/signoz/ee/query-service/dao"
+	"github.com/SigNoz/signoz/ee/licensing/httplicensing"
 	"github.com/SigNoz/signoz/ee/query-service/integrations/gateway"
 	"github.com/SigNoz/signoz/ee/query-service/interfaces"
-	"github.com/SigNoz/signoz/ee/query-service/license"
-	"github.com/SigNoz/signoz/ee/query-service/model"
 	"github.com/SigNoz/signoz/ee/query-service/usage"
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/apis/fields"
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/modules/quickfilter"
-	quickfilterscore "github.com/SigNoz/signoz/pkg/modules/quickfilter/core"
 	baseapp "github.com/SigNoz/signoz/pkg/query-service/app"
 	"github.com/SigNoz/signoz/pkg/query-service/app/cloudintegrations"
 	"github.com/SigNoz/signoz/pkg/query-service/app/integrations"
 	"github.com/SigNoz/signoz/pkg/query-service/app/logparsingpipeline"
-	baseint "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/signoz"
-	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/gorilla/mux"
-	"go.uber.org/zap"
 )
 
 type APIHandlerOptions struct {
 	DataConnector                 interfaces.DataConnector
 	PreferSpanMetrics             bool
-	AppDao                        dao.ModelDao
 	RulesManager                  *rules.Manager
 	UsageManager                  *usage.Manager
-	FeatureFlags                  baseint.FeatureLookup
-	LicenseManager                *license.Manager
 	IntegrationsController        *integrations.Controller
 	CloudIntegrationsController   *cloudintegrations.Controller
 	LogsParsingPipelineController *logparsingpipeline.LogParsingPipelineController
@@ -61,22 +49,18 @@ type APIHandler struct {
 
 // NewAPIHandler returns an APIHandler
 func NewAPIHandler(opts APIHandlerOptions, signoz *signoz.SigNoz) (*APIHandler, error) {
-	quickfiltermodule := quickfilterscore.NewQuickFilters(quickfilterscore.NewStore(signoz.SQLStore))
-	quickFilter := quickfilter.NewAPI(quickfiltermodule)
 	baseHandler, err := baseapp.NewAPIHandler(baseapp.APIHandlerOpts{
 		Reader:                        opts.DataConnector,
 		PreferSpanMetrics:             opts.PreferSpanMetrics,
 		RuleManager:                   opts.RulesManager,
-		FeatureFlags:                  opts.FeatureFlags,
 		IntegrationsController:        opts.IntegrationsController,
 		CloudIntegrationsController:   opts.CloudIntegrationsController,
 		LogsParsingPipelineController: opts.LogsParsingPipelineController,
 		FluxInterval:                  opts.FluxInterval,
 		AlertmanagerAPI:               alertmanager.NewAPI(signoz.Alertmanager),
-		FieldsAPI:                     fields.NewAPI(signoz.TelemetryStore),
+		LicensingAPI:                  httplicensing.NewLicensingAPI(signoz.Licensing),
+		FieldsAPI:                     fields.NewAPI(signoz.TelemetryStore, signoz.Instrumentation.Logger()),
 		Signoz:                        signoz,
-		QuickFilters:                  quickFilter,
-		QuickFilterModule:             quickfiltermodule,
 	})
 
 	if err != nil {
@@ -90,32 +74,20 @@ func NewAPIHandler(opts APIHandlerOptions, signoz *signoz.SigNoz) (*APIHandler,
 	return ah, nil
 }
 
-func (ah *APIHandler) FF() baseint.FeatureLookup {
-	return ah.opts.FeatureFlags
-}
-
 func (ah *APIHandler) RM() *rules.Manager {
 	return ah.opts.RulesManager
 }
 
-func (ah *APIHandler) LM() *license.Manager {
-	return ah.opts.LicenseManager
-}
-
 func (ah *APIHandler) UM() *usage.Manager {
 	return ah.opts.UsageManager
 }
 
-func (ah *APIHandler) AppDao() dao.ModelDao {
-	return ah.opts.AppDao
-}
-
 func (ah *APIHandler) Gateway() *httputil.ReverseProxy {
 	return ah.opts.Gateway
 }
 
-func (ah *APIHandler) CheckFeature(f string) bool {
-	err := ah.FF().CheckFeature(f)
+func (ah *APIHandler) CheckFeature(ctx context.Context, key string) bool {
+	err := ah.Signoz.Licensing.CheckFeature(ctx, key)
 	return err == nil
 }
 
@@ -126,43 +98,29 @@ func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	// routes available only in ee version
 
 	router.HandleFunc("/api/v1/featureFlags", am.OpenAccess(ah.getFeatureFlags)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/loginPrecheck", am.OpenAccess(ah.loginPrecheck)).Methods(http.MethodGet)
+	router.HandleFunc("/api/v1/loginPrecheck", am.OpenAccess(ah.Signoz.Handlers.User.LoginPrecheck)).Methods(http.MethodGet)
 
 	// invite
-	router.HandleFunc("/api/v1/invite/{token}", am.OpenAccess(ah.getInvite)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/invite/accept", am.OpenAccess(ah.acceptInvite)).Methods(http.MethodPost)
+	router.HandleFunc("/api/v1/invite/{token}", am.OpenAccess(ah.Signoz.Handlers.User.GetInvite)).Methods(http.MethodGet)
+	router.HandleFunc("/api/v1/invite/accept", am.OpenAccess(ah.Signoz.Handlers.User.AcceptInvite)).Methods(http.MethodPost)
 
 	// paid plans specific routes
 	router.HandleFunc("/api/v1/complete/saml", am.OpenAccess(ah.receiveSAML)).Methods(http.MethodPost)
-	router.HandleFunc("/api/v1/complete/google", am.OpenAccess(ah.receiveGoogleAuth)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/orgs/{orgId}/domains", am.AdminAccess(ah.listDomainsByOrg)).Methods(http.MethodGet)
-
-	router.HandleFunc("/api/v1/domains", am.AdminAccess(ah.postDomain)).Methods(http.MethodPost)
-	router.HandleFunc("/api/v1/domains/{id}", am.AdminAccess(ah.putDomain)).Methods(http.MethodPut)
-	router.HandleFunc("/api/v1/domains/{id}", am.AdminAccess(ah.deleteDomain)).Methods(http.MethodDelete)
 
 	// base overrides
 	router.HandleFunc("/api/v1/version", am.OpenAccess(ah.getVersion)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/login", am.OpenAccess(ah.loginUser)).Methods(http.MethodPost)
 
-	// PAT APIs
-	router.HandleFunc("/api/v1/pats", am.AdminAccess(ah.createPAT)).Methods(http.MethodPost)
-	router.HandleFunc("/api/v1/pats", am.AdminAccess(ah.getPATs)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/pats/{id}", am.AdminAccess(ah.updatePAT)).Methods(http.MethodPut)
-	router.HandleFunc("/api/v1/pats/{id}", am.AdminAccess(ah.revokePAT)).Methods(http.MethodDelete)
-
-	router.HandleFunc("/api/v1/checkout", am.AdminAccess(ah.checkout)).Methods(http.MethodPost)
+	router.HandleFunc("/api/v1/checkout", am.AdminAccess(ah.LicensingAPI.Checkout)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v1/billing", am.AdminAccess(ah.getBilling)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/portal", am.AdminAccess(ah.portalSession)).Methods(http.MethodPost)
+	router.HandleFunc("/api/v1/portal", am.AdminAccess(ah.LicensingAPI.Portal)).Methods(http.MethodPost)
 
 	router.HandleFunc("/api/v1/dashboards/{uuid}/lock", am.EditAccess(ah.lockDashboard)).Methods(http.MethodPut)
 	router.HandleFunc("/api/v1/dashboards/{uuid}/unlock", am.EditAccess(ah.unlockDashboard)).Methods(http.MethodPut)
 
 	// v3
-	router.HandleFunc("/api/v3/licenses", am.ViewAccess(ah.listLicensesV3)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v3/licenses", am.AdminAccess(ah.applyLicenseV3)).Methods(http.MethodPost)
-	router.HandleFunc("/api/v3/licenses", am.AdminAccess(ah.refreshLicensesV3)).Methods(http.MethodPut)
-	router.HandleFunc("/api/v3/licenses/active", am.ViewAccess(ah.getActiveLicenseV3)).Methods(http.MethodGet)
+	router.HandleFunc("/api/v3/licenses", am.AdminAccess(ah.LicensingAPI.Activate)).Methods(http.MethodPost)
+	router.HandleFunc("/api/v3/licenses", am.AdminAccess(ah.LicensingAPI.Refresh)).Methods(http.MethodPut)
+	router.HandleFunc("/api/v3/licenses/active", am.ViewAccess(ah.LicensingAPI.GetActive)).Methods(http.MethodGet)
 
 	// v4
 	router.HandleFunc("/api/v4/query_range", am.ViewAccess(ah.queryRangeV4)).Methods(http.MethodPost)
@@ -174,54 +132,6 @@ func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 
 }
 
-// TODO(nitya): remove this once we know how to get the FF's
-func (ah *APIHandler) updateRequestContext(w http.ResponseWriter, r *http.Request) (*http.Request, error) {
-	ssoAvailable := true
-	err := ah.FF().CheckFeature(model.SSO)
-	if err != nil {
-		switch err.(type) {
-		case basemodel.ErrFeatureUnavailable:
-			// do nothing, just skip sso
-			ssoAvailable = false
-		default:
-			zap.L().Error("feature check failed", zap.String("featureKey", model.SSO), zap.Error(err))
-			return r, errors.New(errors.TypeInternal, errors.CodeInternal, "error checking SSO feature")
-		}
-	}
-	ctx := context.WithValue(r.Context(), types.SSOAvailable, ssoAvailable)
-	return r.WithContext(ctx), nil
-}
-
-func (ah *APIHandler) loginPrecheck(w http.ResponseWriter, r *http.Request) {
-	r, err := ah.updateRequestContext(w, r)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-	ah.Signoz.Handlers.User.LoginPrecheck(w, r)
-	return
-}
-
-func (ah *APIHandler) acceptInvite(w http.ResponseWriter, r *http.Request) {
-	r, err := ah.updateRequestContext(w, r)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-	ah.Signoz.Handlers.User.AcceptInvite(w, r)
-	return
-}
-
-func (ah *APIHandler) getInvite(w http.ResponseWriter, r *http.Request) {
-	r, err := ah.updateRequestContext(w, r)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-	ah.Signoz.Handlers.User.GetInvite(w, r)
-	return
-}
-
 func (ah *APIHandler) RegisterCloudIntegrationsRoutes(router *mux.Router, am *middleware.AuthZ) {
 
 	ah.APIHandler.RegisterCloudIntegrationsRoutes(router, am)

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

@@ -3,41 +3,16 @@ package api
 import (
 	"context"
 	"encoding/base64"
-	"encoding/json"
 	"fmt"
-	"io"
 	"net/http"
 	"net/url"
 
 	"go.uber.org/zap"
 
-	"github.com/SigNoz/signoz/ee/query-service/constants"
-	"github.com/SigNoz/signoz/ee/query-service/model"
-	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/SigNoz/signoz/pkg/query-service/constants"
+	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
-func parseRequest(r *http.Request, req interface{}) error {
-	defer r.Body.Close()
-	requestBody, err := io.ReadAll(r.Body)
-	if err != nil {
-		return err
-	}
-
-	err = json.Unmarshal(requestBody, &req)
-	return err
-}
-
-// loginUser overrides base handler and considers SSO case.
-func (ah *APIHandler) loginUser(w http.ResponseWriter, r *http.Request) {
-	r, err := ah.updateRequestContext(w, r)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-	ah.Signoz.Handlers.User.Login(w, r)
-	return
-}
-
 func handleSsoError(w http.ResponseWriter, r *http.Request, redirectURL string) {
 	ssoError := []byte("Login failed. Please contact your system administrator")
 	dst := make([]byte, base64.StdEncoding.EncodedLen(len(ssoError)))
@@ -46,84 +21,12 @@ func handleSsoError(w http.ResponseWriter, r *http.Request, redirectURL string)
 	http.Redirect(w, r, fmt.Sprintf("%s?ssoerror=%s", redirectURL, string(dst)), http.StatusSeeOther)
 }
 
-// receiveGoogleAuth completes google OAuth response and forwards a request
-// to front-end to sign user in
-func (ah *APIHandler) receiveGoogleAuth(w http.ResponseWriter, r *http.Request) {
-	redirectUri := constants.GetDefaultSiteURL()
-	ctx := context.Background()
-
-	if !ah.CheckFeature(model.SSO) {
-		zap.L().Error("[receiveGoogleAuth] sso requested but feature unavailable in org domain")
-		http.Redirect(w, r, fmt.Sprintf("%s?ssoerror=%s", redirectUri, "feature unavailable, please upgrade your billing plan to access this feature"), http.StatusMovedPermanently)
-		return
-	}
-
-	q := r.URL.Query()
-	if errType := q.Get("error"); errType != "" {
-		zap.L().Error("[receiveGoogleAuth] failed to login with google auth", zap.String("error", errType), zap.String("error_description", q.Get("error_description")))
-		http.Redirect(w, r, fmt.Sprintf("%s?ssoerror=%s", redirectUri, "failed to login through SSO "), http.StatusMovedPermanently)
-		return
-	}
-
-	relayState := q.Get("state")
-	zap.L().Debug("[receiveGoogleAuth] relay state received", zap.String("state", relayState))
-
-	parsedState, err := url.Parse(relayState)
-	if err != nil || relayState == "" {
-		zap.L().Error("[receiveGoogleAuth] failed to process response - invalid response from IDP", zap.Error(err), zap.Any("request", r))
-		handleSsoError(w, r, redirectUri)
-		return
-	}
-
-	// upgrade redirect url from the relay state for better accuracy
-	redirectUri = fmt.Sprintf("%s://%s%s", parsedState.Scheme, parsedState.Host, "/login")
-
-	// fetch domain by parsing relay state.
-	domain, err := ah.AppDao().GetDomainFromSsoResponse(ctx, parsedState)
-	if err != nil {
-		handleSsoError(w, r, redirectUri)
-		return
-	}
-
-	// now that we have domain, use domain to fetch sso settings.
-	// prepare google callback handler using parsedState -
-	// which contains redirect URL (front-end endpoint)
-	callbackHandler, err := domain.PrepareGoogleOAuthProvider(parsedState)
-	if err != nil {
-		zap.L().Error("[receiveGoogleAuth] failed to prepare google oauth provider", zap.String("domain", domain.String()), zap.Error(err))
-		handleSsoError(w, r, redirectUri)
-		return
-	}
-
-	identity, err := callbackHandler.HandleCallback(r)
-	if err != nil {
-		zap.L().Error("[receiveGoogleAuth] failed to process HandleCallback ", zap.String("domain", domain.String()), zap.Error(err))
-		handleSsoError(w, r, redirectUri)
-		return
-	}
-
-	nextPage, err := ah.Signoz.Modules.User.PrepareSsoRedirect(ctx, redirectUri, identity.Email, ah.opts.JWT)
-	if err != nil {
-		zap.L().Error("[receiveGoogleAuth] failed to generate redirect URI after successful login ", zap.String("domain", domain.String()), zap.Error(err))
-		handleSsoError(w, r, redirectUri)
-		return
-	}
-
-	http.Redirect(w, r, nextPage, http.StatusSeeOther)
-}
-
 // receiveSAML completes a SAML request and gets user logged in
 func (ah *APIHandler) receiveSAML(w http.ResponseWriter, r *http.Request) {
 	// this is the source url that initiated the login request
 	redirectUri := constants.GetDefaultSiteURL()
 	ctx := context.Background()
 
-	if !ah.CheckFeature(model.SSO) {
-		zap.L().Error("[receiveSAML] sso requested but feature unavailable in org domain")
-		http.Redirect(w, r, fmt.Sprintf("%s?ssoerror=%s", redirectUri, "feature unavailable, please upgrade your billing plan to access this feature"), http.StatusMovedPermanently)
-		return
-	}
-
 	err := r.ParseForm()
 	if err != nil {
 		zap.L().Error("[receiveSAML] failed to process response - invalid response from IDP", zap.Error(err), zap.Any("request", r))
@@ -147,12 +50,25 @@ func (ah *APIHandler) receiveSAML(w http.ResponseWriter, r *http.Request) {
 	redirectUri = fmt.Sprintf("%s://%s%s", parsedState.Scheme, parsedState.Host, "/login")
 
 	// fetch domain by parsing relay state.
-	domain, err := ah.AppDao().GetDomainFromSsoResponse(ctx, parsedState)
+	domain, err := ah.Signoz.Modules.User.GetDomainFromSsoResponse(ctx, parsedState)
 	if err != nil {
 		handleSsoError(w, r, redirectUri)
 		return
 	}
 
+	orgID, err := valuer.NewUUID(domain.OrgID)
+	if err != nil {
+		handleSsoError(w, r, redirectUri)
+		return
+	}
+
+	_, err = ah.Signoz.Licensing.GetActive(ctx, orgID)
+	if err != nil {
+		zap.L().Error("[receiveSAML] sso requested but feature unavailable in org domain")
+		http.Redirect(w, r, fmt.Sprintf("%s?ssoerror=%s", redirectUri, "feature unavailable, please upgrade your billing plan to access this feature"), http.StatusMovedPermanently)
+		return
+	}
+
 	sp, err := domain.PrepareSamlRequest(parsedState)
 	if err != nil {
 		zap.L().Error("[receiveSAML] failed to prepare saml request for domain", zap.String("domain", domain.String()), zap.Error(err))

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

@@ -11,12 +11,12 @@ import (
 	"time"
 
 	"github.com/SigNoz/signoz/ee/query-service/constants"
-	eeTypes "github.com/SigNoz/signoz/ee/types"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/http/render"
 	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/google/uuid"
 	"github.com/gorilla/mux"
 	"go.uber.org/zap"
@@ -36,6 +36,12 @@ func (ah *APIHandler) CloudIntegrationsGenerateConnectionParams(w http.ResponseW
 		return
 	}
 
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(w, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "orgId is invalid"))
+		return
+	}
+
 	cloudProvider := mux.Vars(r)["cloudProvider"]
 	if cloudProvider != "aws" {
 		RespondError(w, basemodel.BadRequest(fmt.Errorf(
@@ -56,11 +62,9 @@ func (ah *APIHandler) CloudIntegrationsGenerateConnectionParams(w http.ResponseW
 		SigNozAPIKey: apiKey,
 	}
 
-	license, apiErr := ah.LM().GetRepo().GetActiveLicense(r.Context())
-	if apiErr != nil {
-		RespondError(w, basemodel.WrapApiError(
-			apiErr, "couldn't look for active license",
-		), nil)
+	license, err := ah.Signoz.Licensing.GetActive(r.Context(), orgID)
+	if err != nil {
+		render.Error(w, err)
 		return
 	}
 
@@ -116,14 +120,21 @@ func (ah *APIHandler) getOrCreateCloudIntegrationPAT(ctx context.Context, orgId
 		return "", apiErr
 	}
 
-	allPats, err := ah.AppDao().ListPATs(ctx, orgId)
+	orgIdUUID, err := valuer.NewUUID(orgId)
+	if err != nil {
+		return "", basemodel.InternalError(fmt.Errorf(
+			"couldn't parse orgId: %w", err,
+		))
+	}
+
+	allPats, err := ah.Signoz.Modules.User.ListAPIKeys(ctx, orgIdUUID)
 	if err != nil {
 		return "", basemodel.InternalError(fmt.Errorf(
 			"couldn't list PATs: %w", err,
 		))
 	}
 	for _, p := range allPats {
-		if p.UserID == integrationUser.ID.String() && p.Name == integrationPATName {
+		if p.UserID == integrationUser.ID && p.Name == integrationPATName {
 			return p.Token, nil
 		}
 	}
@@ -133,19 +144,25 @@ func (ah *APIHandler) getOrCreateCloudIntegrationPAT(ctx context.Context, orgId
 		zap.String("cloudProvider", cloudProvider),
 	)
 
-	newPAT := eeTypes.NewGettablePAT(
+	newPAT, err := types.NewStorableAPIKey(
 		integrationPATName,
-		types.RoleViewer.String(),
-		integrationUser.ID.String(),
+		integrationUser.ID,
+		types.RoleViewer,
 		0,
 	)
-	integrationPAT, err := ah.AppDao().CreatePAT(ctx, orgId, newPAT)
 	if err != nil {
 		return "", basemodel.InternalError(fmt.Errorf(
 			"couldn't create cloud integration PAT: %w", err,
 		))
 	}
-	return integrationPAT.Token, nil
+
+	err = ah.Signoz.Modules.User.CreateAPIKey(ctx, newPAT)
+	if err != nil {
+		return "", basemodel.InternalError(fmt.Errorf(
+			"couldn't create cloud integration PAT: %w", err,
+		))
+	}
+	return newPAT.Token, nil
 }
 
 func (ah *APIHandler) getOrCreateCloudIntegrationUser(

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

@@ -1,91 +0,0 @@
-package api
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-
-	"github.com/SigNoz/signoz/ee/query-service/model"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/google/uuid"
-	"github.com/gorilla/mux"
-)
-
-func (ah *APIHandler) listDomainsByOrg(w http.ResponseWriter, r *http.Request) {
-	orgId := mux.Vars(r)["orgId"]
-	domains, apierr := ah.AppDao().ListDomains(context.Background(), orgId)
-	if apierr != nil {
-		RespondError(w, apierr, domains)
-		return
-	}
-	ah.Respond(w, domains)
-}
-
-func (ah *APIHandler) postDomain(w http.ResponseWriter, r *http.Request) {
-	ctx := context.Background()
-
-	req := types.GettableOrgDomain{}
-
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		RespondError(w, model.BadRequest(err), nil)
-		return
-	}
-
-	if err := req.ValidNew(); err != nil {
-		RespondError(w, model.BadRequest(err), nil)
-		return
-	}
-
-	if apierr := ah.AppDao().CreateDomain(ctx, &req); apierr != nil {
-		RespondError(w, apierr, nil)
-		return
-	}
-
-	ah.Respond(w, &req)
-}
-
-func (ah *APIHandler) putDomain(w http.ResponseWriter, r *http.Request) {
-	ctx := context.Background()
-
-	domainIdStr := mux.Vars(r)["id"]
-	domainId, err := uuid.Parse(domainIdStr)
-	if err != nil {
-		RespondError(w, model.BadRequest(err), nil)
-		return
-	}
-
-	req := types.GettableOrgDomain{StorableOrgDomain: types.StorableOrgDomain{ID: domainId}}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		RespondError(w, model.BadRequest(err), nil)
-		return
-	}
-	req.ID = domainId
-	if err := req.Valid(nil); err != nil {
-		RespondError(w, model.BadRequest(err), nil)
-	}
-
-	if apierr := ah.AppDao().UpdateDomain(ctx, &req); apierr != nil {
-		RespondError(w, apierr, nil)
-		return
-	}
-
-	ah.Respond(w, &req)
-}
-
-func (ah *APIHandler) deleteDomain(w http.ResponseWriter, r *http.Request) {
-	domainIdStr := mux.Vars(r)["id"]
-
-	domainId, err := uuid.Parse(domainIdStr)
-	if err != nil {
-		RespondError(w, model.BadRequest(fmt.Errorf("invalid domain id")), nil)
-		return
-	}
-
-	apierr := ah.AppDao().DeleteDomain(context.Background(), domainId)
-	if apierr != nil {
-		RespondError(w, apierr, nil)
-		return
-	}
-	ah.Respond(w, nil)
-}

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

@@ -9,13 +9,29 @@ import (
 	"time"
 
 	"github.com/SigNoz/signoz/ee/query-service/constants"
-	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
+	pkgError "github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/featuretypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
 	"go.uber.org/zap"
 )
 
 func (ah *APIHandler) getFeatureFlags(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	featureSet, err := ah.FF().GetFeatureFlags()
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(w, pkgError.Newf(pkgError.TypeInvalidInput, pkgError.CodeInvalidInput, "orgId is invalid"))
+		return
+	}
+
+	featureSet, err := ah.Signoz.Licensing.GetFeatureFlags(r.Context())
 	if err != nil {
 		ah.HandleError(w, err, http.StatusInternalServerError)
 		return
@@ -23,7 +39,7 @@ func (ah *APIHandler) getFeatureFlags(w http.ResponseWriter, r *http.Request) {
 
 	if constants.FetchFeatures == "true" {
 		zap.L().Debug("fetching license")
-		license, err := ah.LM().GetRepo().GetActiveLicense(ctx)
+		license, err := ah.Signoz.Licensing.GetActive(ctx, orgID)
 		if err != nil {
 			zap.L().Error("failed to fetch license", zap.Error(err))
 		} else if license == nil {
@@ -44,9 +60,8 @@ func (ah *APIHandler) getFeatureFlags(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if ah.opts.PreferSpanMetrics {
-		for idx := range featureSet {
-			feature := &featureSet[idx]
-			if feature.Name == basemodel.UseSpanMetrics {
+		for idx, feature := range featureSet {
+			if feature.Name == featuretypes.UseSpanMetrics {
 				featureSet[idx].Active = true
 			}
 		}
@@ -57,7 +72,7 @@ func (ah *APIHandler) getFeatureFlags(w http.ResponseWriter, r *http.Request) {
 
 // fetchZeusFeatures makes an HTTP GET request to the /zeusFeatures endpoint
 // and returns the FeatureSet.
-func fetchZeusFeatures(url, licenseKey string) (basemodel.FeatureSet, error) {
+func fetchZeusFeatures(url, licenseKey string) ([]*featuretypes.GettableFeature, error) {
 	// Check if the URL is empty
 	if url == "" {
 		return nil, fmt.Errorf("url is empty")
@@ -116,14 +131,14 @@ func fetchZeusFeatures(url, licenseKey string) (basemodel.FeatureSet, error) {
 }
 
 type ZeusFeaturesResponse struct {
-	Status string               `json:"status"`
-	Data   basemodel.FeatureSet `json:"data"`
+	Status string                          `json:"status"`
+	Data   []*featuretypes.GettableFeature `json:"data"`
 }
 
 // MergeFeatureSets merges two FeatureSet arrays with precedence to zeusFeatures.
-func MergeFeatureSets(zeusFeatures, internalFeatures basemodel.FeatureSet) basemodel.FeatureSet {
+func MergeFeatureSets(zeusFeatures, internalFeatures []*featuretypes.GettableFeature) []*featuretypes.GettableFeature {
 	// Create a map to store the merged features
-	featureMap := make(map[string]basemodel.Feature)
+	featureMap := make(map[string]*featuretypes.GettableFeature)
 
 	// Add all features from the otherFeatures set to the map
 	for _, feature := range internalFeatures {
@@ -137,7 +152,7 @@ func MergeFeatureSets(zeusFeatures, internalFeatures basemodel.FeatureSet) basem
 	}
 
 	// Convert the map back to a FeatureSet slice
-	var mergedFeatures basemodel.FeatureSet
+	var mergedFeatures []*featuretypes.GettableFeature
 	for _, feature := range featureMap {
 		mergedFeatures = append(mergedFeatures, feature)
 	}

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

@@ -3,58 +3,58 @@ package api
 import (
 	"testing"
 
-	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
+	"github.com/SigNoz/signoz/pkg/types/featuretypes"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestMergeFeatureSets(t *testing.T) {
 	tests := []struct {
 		name             string
-		zeusFeatures     basemodel.FeatureSet
-		internalFeatures basemodel.FeatureSet
-		expected         basemodel.FeatureSet
+		zeusFeatures     []*featuretypes.GettableFeature
+		internalFeatures []*featuretypes.GettableFeature
+		expected         []*featuretypes.GettableFeature
 	}{
 		{
 			name:             "empty zeusFeatures and internalFeatures",
-			zeusFeatures:     basemodel.FeatureSet{},
-			internalFeatures: basemodel.FeatureSet{},
-			expected:         basemodel.FeatureSet{},
+			zeusFeatures:     []*featuretypes.GettableFeature{},
+			internalFeatures: []*featuretypes.GettableFeature{},
+			expected:         []*featuretypes.GettableFeature{},
 		},
 		{
 			name: "non-empty zeusFeatures and empty internalFeatures",
-			zeusFeatures: basemodel.FeatureSet{
+			zeusFeatures: []*featuretypes.GettableFeature{
 				{Name: "Feature1", Active: true},
 				{Name: "Feature2", Active: false},
 			},
-			internalFeatures: basemodel.FeatureSet{},
-			expected: basemodel.FeatureSet{
+			internalFeatures: []*featuretypes.GettableFeature{},
+			expected: []*featuretypes.GettableFeature{
 				{Name: "Feature1", Active: true},
 				{Name: "Feature2", Active: false},
 			},
 		},
 		{
 			name:         "empty zeusFeatures and non-empty internalFeatures",
-			zeusFeatures: basemodel.FeatureSet{},
-			internalFeatures: basemodel.FeatureSet{
+			zeusFeatures: []*featuretypes.GettableFeature{},
+			internalFeatures: []*featuretypes.GettableFeature{
 				{Name: "Feature1", Active: true},
 				{Name: "Feature2", Active: false},
 			},
-			expected: basemodel.FeatureSet{
+			expected: []*featuretypes.GettableFeature{
 				{Name: "Feature1", Active: true},
 				{Name: "Feature2", Active: false},
 			},
 		},
 		{
 			name: "non-empty zeusFeatures and non-empty internalFeatures with no conflicts",
-			zeusFeatures: basemodel.FeatureSet{
+			zeusFeatures: []*featuretypes.GettableFeature{
 				{Name: "Feature1", Active: true},
 				{Name: "Feature3", Active: false},
 			},
-			internalFeatures: basemodel.FeatureSet{
+			internalFeatures: []*featuretypes.GettableFeature{
 				{Name: "Feature2", Active: true},
 				{Name: "Feature4", Active: false},
 			},
-			expected: basemodel.FeatureSet{
+			expected: []*featuretypes.GettableFeature{
 				{Name: "Feature1", Active: true},
 				{Name: "Feature2", Active: true},
 				{Name: "Feature3", Active: false},
@@ -63,15 +63,15 @@ func TestMergeFeatureSets(t *testing.T) {
 		},
 		{
 			name: "non-empty zeusFeatures and non-empty internalFeatures with conflicts",
-			zeusFeatures: basemodel.FeatureSet{
+			zeusFeatures: []*featuretypes.GettableFeature{
 				{Name: "Feature1", Active: true},
 				{Name: "Feature2", Active: false},
 			},
-			internalFeatures: basemodel.FeatureSet{
+			internalFeatures: []*featuretypes.GettableFeature{
 				{Name: "Feature1", Active: false},
 				{Name: "Feature3", Active: true},
 			},
-			expected: basemodel.FeatureSet{
+			expected: []*featuretypes.GettableFeature{
 				{Name: "Feature1", Active: true},
 				{Name: "Feature2", Active: false},
 				{Name: "Feature3", Active: true},

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

@@ -5,10 +5,26 @@ import (
 	"strings"
 
 	"github.com/SigNoz/signoz/ee/query-service/integrations/gateway"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
 func (ah *APIHandler) ServeGatewayHTTP(rw http.ResponseWriter, req *http.Request) {
 	ctx := req.Context()
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "orgId is invalid"))
+		return
+	}
+
 	validPath := false
 	for _, allowedPrefix := range gateway.AllowedPrefix {
 		if strings.HasPrefix(req.URL.Path, gateway.RoutePrefix+allowedPrefix) {
@@ -22,9 +38,9 @@ func (ah *APIHandler) ServeGatewayHTTP(rw http.ResponseWriter, req *http.Request
 		return
 	}
 
-	license, err := ah.LM().GetRepo().GetActiveLicense(ctx)
+	license, err := ah.Signoz.Licensing.GetActive(ctx, orgID)
 	if err != nil {
-		RespondError(rw, err, nil)
+		render.Error(rw, err)
 		return
 	}
 

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

@@ -6,11 +6,7 @@ import (
 	"net/http"
 
 	"github.com/SigNoz/signoz/ee/query-service/constants"
-	"github.com/SigNoz/signoz/ee/query-service/integrations/signozio"
 	"github.com/SigNoz/signoz/ee/query-service/model"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/query-service/telemetry"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
 )
 
 type DayWiseBreakdown struct {
@@ -49,10 +45,6 @@ type details struct {
 	BillTotal float64         `json:"billTotal"`
 }
 
-type Redirect struct {
-	RedirectURL string `json:"redirectURL"`
-}
-
 type billingDetails struct {
 	Status string `json:"status"`
 	Data   struct {
@@ -64,97 +56,6 @@ type billingDetails struct {
 	} `json:"data"`
 }
 
-type ApplyLicenseRequest struct {
-	LicenseKey string `json:"key"`
-}
-
-func (ah *APIHandler) listLicensesV3(w http.ResponseWriter, r *http.Request) {
-	ah.listLicensesV2(w, r)
-}
-
-func (ah *APIHandler) getActiveLicenseV3(w http.ResponseWriter, r *http.Request) {
-	activeLicense, err := ah.LM().GetRepo().GetActiveLicenseV3(r.Context())
-	if err != nil {
-		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: err}, nil)
-		return
-	}
-
-	// return 404 not found if there is no active license
-	if activeLicense == nil {
-		RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("no active license found")}, nil)
-		return
-	}
-
-	// TODO deprecate this when we move away from key for stripe
-	activeLicense.Data["key"] = activeLicense.Key
-	render.Success(w, http.StatusOK, activeLicense.Data)
-}
-
-// this function is called by zeus when inserting licenses in the query-service
-func (ah *APIHandler) applyLicenseV3(w http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	var licenseKey ApplyLicenseRequest
-	if err := json.NewDecoder(r.Body).Decode(&licenseKey); err != nil {
-		RespondError(w, model.BadRequest(err), nil)
-		return
-	}
-
-	if licenseKey.LicenseKey == "" {
-		RespondError(w, model.BadRequest(fmt.Errorf("license key is required")), nil)
-		return
-	}
-
-	_, err = ah.LM().ActivateV3(r.Context(), licenseKey.LicenseKey)
-	if err != nil {
-		telemetry.GetInstance().SendEvent(telemetry.TELEMETRY_LICENSE_ACT_FAILED, map[string]interface{}{"err": err.Error()}, claims.Email, true, false)
-		render.Error(w, err)
-		return
-	}
-
-	render.Success(w, http.StatusAccepted, nil)
-}
-
-func (ah *APIHandler) refreshLicensesV3(w http.ResponseWriter, r *http.Request) {
-	err := ah.LM().RefreshLicense(r.Context())
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	render.Success(w, http.StatusNoContent, nil)
-}
-
-func getCheckoutPortalResponse(redirectURL string) *Redirect {
-	return &Redirect{RedirectURL: redirectURL}
-}
-
-func (ah *APIHandler) checkout(w http.ResponseWriter, r *http.Request) {
-	checkoutRequest := &model.CheckoutRequest{}
-	if err := json.NewDecoder(r.Body).Decode(checkoutRequest); err != nil {
-		RespondError(w, model.BadRequest(err), nil)
-		return
-	}
-
-	license := ah.LM().GetActiveLicense()
-	if license == nil {
-		RespondError(w, model.BadRequestStr("cannot proceed with checkout without license key"), nil)
-		return
-	}
-
-	redirectUrl, err := signozio.CheckoutSession(r.Context(), checkoutRequest, license.Key, ah.Signoz.Zeus)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	ah.Respond(w, getCheckoutPortalResponse(redirectUrl))
-}
-
 func (ah *APIHandler) getBilling(w http.ResponseWriter, r *http.Request) {
 	licenseKey := r.URL.Query().Get("licenseKey")
 
@@ -188,71 +89,3 @@ func (ah *APIHandler) getBilling(w http.ResponseWriter, r *http.Request) {
 	// TODO(srikanthccv):Fetch the current day usage and add it to the response
 	ah.Respond(w, billingResponse.Data)
 }
-
-func convertLicenseV3ToLicenseV2(licenses []*model.LicenseV3) []model.License {
-	licensesV2 := []model.License{}
-	for _, l := range licenses {
-		planKeyFromPlanName, ok := model.MapOldPlanKeyToNewPlanName[l.PlanName]
-		if !ok {
-			planKeyFromPlanName = model.Basic
-		}
-		licenseV2 := model.License{
-			Key:               l.Key,
-			ActivationId:      "",
-			PlanDetails:       "",
-			FeatureSet:        l.Features,
-			ValidationMessage: "",
-			IsCurrent:         l.IsCurrent,
-			LicensePlan: model.LicensePlan{
-				PlanKey:    planKeyFromPlanName,
-				ValidFrom:  l.ValidFrom,
-				ValidUntil: l.ValidUntil,
-				Status:     l.Status},
-		}
-		licensesV2 = append(licensesV2, licenseV2)
-	}
-	return licensesV2
-}
-
-func (ah *APIHandler) listLicensesV2(w http.ResponseWriter, r *http.Request) {
-	licensesV3, apierr := ah.LM().GetLicensesV3(r.Context())
-	if apierr != nil {
-		RespondError(w, apierr, nil)
-		return
-	}
-	licenses := convertLicenseV3ToLicenseV2(licensesV3)
-
-	resp := model.Licenses{
-		TrialStart:                   -1,
-		TrialEnd:                     -1,
-		OnTrial:                      false,
-		WorkSpaceBlock:               false,
-		TrialConvertedToSubscription: false,
-		GracePeriodEnd:               -1,
-		Licenses:                     licenses,
-	}
-
-	ah.Respond(w, resp)
-}
-
-func (ah *APIHandler) portalSession(w http.ResponseWriter, r *http.Request) {
-	portalRequest := &model.PortalRequest{}
-	if err := json.NewDecoder(r.Body).Decode(portalRequest); err != nil {
-		RespondError(w, model.BadRequest(err), nil)
-		return
-	}
-
-	license := ah.LM().GetActiveLicense()
-	if license == nil {
-		RespondError(w, model.BadRequestStr("cannot request the portal session without license key"), nil)
-		return
-	}
-
-	redirectUrl, err := signozio.PortalSession(r.Context(), portalRequest, license.Key, ah.Signoz.Zeus)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	ah.Respond(w, getCheckoutPortalResponse(redirectUrl))
-}

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

@@ -1,186 +0,0 @@
-package api
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"slices"
-	"time"
-
-	"github.com/SigNoz/signoz/ee/query-service/model"
-	eeTypes "github.com/SigNoz/signoz/ee/types"
-	"github.com/SigNoz/signoz/pkg/errors"
-	errorsV2 "github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/gorilla/mux"
-	"go.uber.org/zap"
-)
-
-func (ah *APIHandler) createPAT(w http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	req := model.CreatePATRequestBody{}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		RespondError(w, model.BadRequest(err), nil)
-		return
-	}
-
-	pat := eeTypes.NewGettablePAT(
-		req.Name,
-		req.Role,
-		claims.UserID,
-		req.ExpiresInDays,
-	)
-	err = validatePATRequest(pat)
-	if err != nil {
-		RespondError(w, model.BadRequest(err), nil)
-		return
-	}
-
-	zap.L().Info("Got Create PAT request", zap.Any("pat", pat))
-	var apierr basemodel.BaseApiError
-	if pat, apierr = ah.AppDao().CreatePAT(r.Context(), claims.OrgID, pat); apierr != nil {
-		RespondError(w, apierr, nil)
-		return
-	}
-
-	ah.Respond(w, &pat)
-}
-
-func validatePATRequest(req eeTypes.GettablePAT) error {
-	_, err := types.NewRole(req.Role)
-	if err != nil {
-		return err
-	}
-
-	if req.ExpiresAt < 0 {
-		return fmt.Errorf("valid expiresAt is required")
-	}
-
-	if req.Name == "" {
-		return fmt.Errorf("valid name is required")
-	}
-
-	return nil
-}
-
-func (ah *APIHandler) updatePAT(w http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	req := eeTypes.GettablePAT{}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		RespondError(w, model.BadRequest(err), nil)
-		return
-	}
-
-	idStr := mux.Vars(r)["id"]
-	id, err := valuer.NewUUID(idStr)
-	if err != nil {
-		render.Error(w, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
-		return
-	}
-
-	//get the pat
-	existingPAT, err := ah.AppDao().GetPATByID(r.Context(), claims.OrgID, id)
-	if err != nil {
-		render.Error(w, errorsV2.Newf(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, err.Error()))
-		return
-	}
-
-	// get the user
-	createdByUser, err := ah.Signoz.Modules.User.GetUserByID(r.Context(), claims.OrgID, existingPAT.UserID)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	if slices.Contains(types.AllIntegrationUserEmails, types.IntegrationUserEmail(createdByUser.Email)) {
-		render.Error(w, errorsV2.Newf(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, "integration user pat cannot be updated"))
-		return
-	}
-
-	err = validatePATRequest(req)
-	if err != nil {
-		RespondError(w, model.BadRequest(err), nil)
-		return
-	}
-
-	req.UpdatedByUserID = claims.UserID
-	req.UpdatedAt = time.Now()
-	var apierr basemodel.BaseApiError
-	if apierr = ah.AppDao().UpdatePAT(r.Context(), claims.OrgID, req, id); apierr != nil {
-		RespondError(w, apierr, nil)
-		return
-	}
-
-	ah.Respond(w, map[string]string{"data": "pat updated successfully"})
-}
-
-func (ah *APIHandler) getPATs(w http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	pats, apierr := ah.AppDao().ListPATs(r.Context(), claims.OrgID)
-	if apierr != nil {
-		RespondError(w, apierr, nil)
-		return
-	}
-
-	ah.Respond(w, pats)
-}
-
-func (ah *APIHandler) revokePAT(w http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	idStr := mux.Vars(r)["id"]
-	id, err := valuer.NewUUID(idStr)
-	if err != nil {
-		render.Error(w, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
-		return
-	}
-
-	//get the pat
-	existingPAT, paterr := ah.AppDao().GetPATByID(r.Context(), claims.OrgID, id)
-	if paterr != nil {
-		render.Error(w, errorsV2.Newf(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, paterr.Error()))
-		return
-	}
-
-	// get the user
-	createdByUser, err := ah.Signoz.Modules.User.GetUserByID(r.Context(), claims.OrgID, existingPAT.UserID)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	if slices.Contains(types.AllIntegrationUserEmails, types.IntegrationUserEmail(createdByUser.Email)) {
-		render.Error(w, errorsV2.Newf(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, "integration user pat cannot be updated"))
-		return
-	}
-
-	zap.L().Info("Revoke PAT with id", zap.String("id", id.StringValue()))
-	if apierr := ah.AppDao().RevokePAT(r.Context(), claims.OrgID, id, claims.UserID); apierr != nil {
-		RespondError(w, apierr, nil)
-		return
-	}
-	ah.Respond(w, map[string]string{"data": "pat revoked successfully"})
-}

ee/query-service/app/server.go

@@ -11,13 +11,12 @@ import (
 	"github.com/gorilla/handlers"
 	"github.com/jmoiron/sqlx"
 
-	eemiddleware "github.com/SigNoz/signoz/ee/http/middleware"
 	"github.com/SigNoz/signoz/ee/query-service/app/api"
 	"github.com/SigNoz/signoz/ee/query-service/app/db"
 	"github.com/SigNoz/signoz/ee/query-service/constants"
-	"github.com/SigNoz/signoz/ee/query-service/dao/sqlite"
 	"github.com/SigNoz/signoz/ee/query-service/integrations/gateway"
 	"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"
@@ -30,9 +29,6 @@ import (
 	"github.com/rs/cors"
 	"github.com/soheilhy/cmux"
 
-	licensepkg "github.com/SigNoz/signoz/ee/query-service/license"
-	"github.com/SigNoz/signoz/ee/query-service/usage"
-
 	"github.com/SigNoz/signoz/pkg/query-service/agentConf"
 	baseapp "github.com/SigNoz/signoz/pkg/query-service/app"
 	"github.com/SigNoz/signoz/pkg/query-service/app/cloudintegrations"
@@ -90,18 +86,11 @@ func (s Server) HealthCheckStatus() chan healthcheck.Status {
 
 // NewServer creates and initializes Server
 func NewServer(serverOptions *ServerOptions) (*Server, error) {
-	modelDao := sqlite.NewModelDao(serverOptions.SigNoz.SQLStore)
 	gatewayProxy, err := gateway.NewProxy(serverOptions.GatewayUrl, gateway.RoutePrefix)
 	if err != nil {
 		return nil, err
 	}
 
-	// initiate license manager
-	lm, err := licensepkg.StartManager(serverOptions.SigNoz.SQLStore.SQLxDB(), serverOptions.SigNoz.SQLStore, serverOptions.SigNoz.Zeus)
-	if err != nil {
-		return nil, err
-	}
-
 	fluxIntervalForTraceDetail, err := time.ParseDuration(serverOptions.FluxIntervalForTraceDetail)
 	if err != nil {
 		return nil, err
@@ -168,11 +157,11 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 	}
 
 	// start the usagemanager
-	usageManager, err := usage.New(modelDao, lm.GetRepo(), serverOptions.SigNoz.TelemetryStore.ClickhouseDB(), serverOptions.SigNoz.Zeus)
+	usageManager, err := usage.New(serverOptions.SigNoz.Licensing, serverOptions.SigNoz.TelemetryStore.ClickhouseDB(), serverOptions.SigNoz.Zeus, serverOptions.SigNoz.Modules.Organization)
 	if err != nil {
 		return nil, err
 	}
-	err = usageManager.Start()
+	err = usageManager.Start(context.Background())
 	if err != nil {
 		return nil, err
 	}
@@ -194,11 +183,8 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 	apiOpts := api.APIHandlerOptions{
 		DataConnector:                 reader,
 		PreferSpanMetrics:             serverOptions.PreferSpanMetrics,
-		AppDao:                        modelDao,
 		RulesManager:                  rm,
 		UsageManager:                  usageManager,
-		FeatureFlags:                  lm,
-		LicenseManager:                lm,
 		IntegrationsController:        integrationsController,
 		CloudIntegrationsController:   cloudIntegrationsController,
 		LogsParsingPipelineController: logParsingPipelineController,
@@ -257,15 +243,15 @@ func (s *Server) createPrivateServer(apiHandler *api.APIHandler) (*http.Server,
 
 	r := baseapp.NewRouter()
 
-	r.Use(middleware.NewAuth(zap.L(), s.serverOptions.Jwt, []string{"Authorization", "Sec-WebSocket-Protocol"}).Wrap)
-	r.Use(eemiddleware.NewPat(s.serverOptions.SigNoz.SQLStore, []string{"SIGNOZ-API-KEY"}).Wrap)
-	r.Use(middleware.NewTimeout(zap.L(),
+	r.Use(middleware.NewAuth(s.serverOptions.Jwt, []string{"Authorization", "Sec-WebSocket-Protocol"}).Wrap)
+	r.Use(middleware.NewAPIKey(s.serverOptions.SigNoz.SQLStore, []string{"SIGNOZ-API-KEY"}, s.serverOptions.SigNoz.Instrumentation.Logger()).Wrap)
+	r.Use(middleware.NewTimeout(s.serverOptions.SigNoz.Instrumentation.Logger(),
 		s.serverOptions.Config.APIServer.Timeout.ExcludedRoutes,
 		s.serverOptions.Config.APIServer.Timeout.Default,
 		s.serverOptions.Config.APIServer.Timeout.Max,
 	).Wrap)
-	r.Use(middleware.NewAnalytics(zap.L()).Wrap)
-	r.Use(middleware.NewLogging(zap.L(), s.serverOptions.Config.APIServer.Logging.ExcludedRoutes).Wrap)
+	r.Use(middleware.NewAnalytics().Wrap)
+	r.Use(middleware.NewLogging(s.serverOptions.SigNoz.Instrumentation.Logger(), s.serverOptions.Config.APIServer.Logging.ExcludedRoutes).Wrap)
 
 	apiHandler.RegisterPrivateRoutes(r)
 
@@ -289,15 +275,15 @@ func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*h
 	r := baseapp.NewRouter()
 	am := middleware.NewAuthZ(s.serverOptions.SigNoz.Instrumentation.Logger())
 
-	r.Use(middleware.NewAuth(zap.L(), s.serverOptions.Jwt, []string{"Authorization", "Sec-WebSocket-Protocol"}).Wrap)
-	r.Use(eemiddleware.NewPat(s.serverOptions.SigNoz.SQLStore, []string{"SIGNOZ-API-KEY"}).Wrap)
-	r.Use(middleware.NewTimeout(zap.L(),
+	r.Use(middleware.NewAuth(s.serverOptions.Jwt, []string{"Authorization", "Sec-WebSocket-Protocol"}).Wrap)
+	r.Use(middleware.NewAPIKey(s.serverOptions.SigNoz.SQLStore, []string{"SIGNOZ-API-KEY"}, s.serverOptions.SigNoz.Instrumentation.Logger()).Wrap)
+	r.Use(middleware.NewTimeout(s.serverOptions.SigNoz.Instrumentation.Logger(),
 		s.serverOptions.Config.APIServer.Timeout.ExcludedRoutes,
 		s.serverOptions.Config.APIServer.Timeout.Default,
 		s.serverOptions.Config.APIServer.Timeout.Max,
 	).Wrap)
-	r.Use(middleware.NewAnalytics(zap.L()).Wrap)
-	r.Use(middleware.NewLogging(zap.L(), s.serverOptions.Config.APIServer.Logging.ExcludedRoutes).Wrap)
+	r.Use(middleware.NewAnalytics().Wrap)
+	r.Use(middleware.NewLogging(s.serverOptions.SigNoz.Instrumentation.Logger(), s.serverOptions.Config.APIServer.Logging.ExcludedRoutes).Wrap)
 
 	apiHandler.RegisterRoutes(r, am)
 	apiHandler.RegisterLogsRoutes(r, am)
@@ -431,15 +417,15 @@ func (s *Server) Start(ctx context.Context) error {
 	return nil
 }
 
-func (s *Server) Stop() error {
+func (s *Server) Stop(ctx context.Context) error {
 	if s.httpServer != nil {
-		if err := s.httpServer.Shutdown(context.Background()); err != nil {
+		if err := s.httpServer.Shutdown(ctx); err != nil {
 			return err
 		}
 	}
 
 	if s.privateHTTP != nil {
-		if err := s.privateHTTP.Shutdown(context.Background()); err != nil {
+		if err := s.privateHTTP.Shutdown(ctx); err != nil {
 			return err
 		}
 	}
@@ -447,11 +433,11 @@ func (s *Server) Stop() error {
 	s.opampServer.Stop()
 
 	if s.ruleManager != nil {
-		s.ruleManager.Stop(context.Background())
+		s.ruleManager.Stop(ctx)
 	}
 
 	// stop usage manager
-	s.usageManager.Stop()
+	s.usageManager.Stop(ctx)
 
 	return nil
 }

ee/query-service/constants/constants.go

@@ -4,10 +4,6 @@ import (
 	"os"
 )
 
-const (
-	DefaultSiteURL = "https://localhost:8080"
-)
-
 var LicenseSignozIo = "https://license.signoz.io/api/v1"
 var LicenseAPIKey = GetOrDefaultEnv("SIGNOZ_LICENSE_API_KEY", "")
 var SaasSegmentKey = GetOrDefaultEnv("SIGNOZ_SAAS_SEGMENT_KEY", "")
@@ -24,12 +20,3 @@ func GetOrDefaultEnv(key string, fallback string) string {
 	}
 	return v
 }
-
-// constant functions that override env vars
-
-// GetDefaultSiteURL returns default site url, primarily
-// used to send saml request and allowing backend to
-// handle http redirect
-func GetDefaultSiteURL() string {
-	return GetOrDefaultEnv("SIGNOZ_SITE_URL", DefaultSiteURL)
-}

ee/query-service/dao/interface.go

@@ -1,32 +0,0 @@
-package dao
-
-import (
-	"context"
-	"net/url"
-
-	eeTypes "github.com/SigNoz/signoz/ee/types"
-	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/google/uuid"
-)
-
-type ModelDao interface {
-	// auth methods
-	GetDomainFromSsoResponse(ctx context.Context, relayState *url.URL) (*types.GettableOrgDomain, error)
-
-	// org domain (auth domains) CRUD ops
-	ListDomains(ctx context.Context, orgId string) ([]types.GettableOrgDomain, basemodel.BaseApiError)
-	GetDomain(ctx context.Context, id uuid.UUID) (*types.GettableOrgDomain, basemodel.BaseApiError)
-	CreateDomain(ctx context.Context, d *types.GettableOrgDomain) basemodel.BaseApiError
-	UpdateDomain(ctx context.Context, domain *types.GettableOrgDomain) basemodel.BaseApiError
-	DeleteDomain(ctx context.Context, id uuid.UUID) basemodel.BaseApiError
-	GetDomainByEmail(ctx context.Context, email string) (*types.GettableOrgDomain, basemodel.BaseApiError)
-
-	CreatePAT(ctx context.Context, orgID string, p eeTypes.GettablePAT) (eeTypes.GettablePAT, basemodel.BaseApiError)
-	UpdatePAT(ctx context.Context, orgID string, p eeTypes.GettablePAT, id valuer.UUID) basemodel.BaseApiError
-	GetPAT(ctx context.Context, pat string) (*eeTypes.GettablePAT, basemodel.BaseApiError)
-	GetPATByID(ctx context.Context, orgID string, id valuer.UUID) (*eeTypes.GettablePAT, basemodel.BaseApiError)
-	ListPATs(ctx context.Context, orgID string) ([]eeTypes.GettablePAT, basemodel.BaseApiError)
-	RevokePAT(ctx context.Context, orgID string, id valuer.UUID, userID string) basemodel.BaseApiError
-}

ee/query-service/dao/sqlite/domain.go

@@ -1,272 +0,0 @@
-package sqlite
-
-import (
-	"context"
-	"database/sql"
-	"encoding/json"
-	"fmt"
-	"net/url"
-	"strings"
-	"time"
-
-	"github.com/SigNoz/signoz/ee/query-service/model"
-	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
-	"github.com/SigNoz/signoz/pkg/types"
-	ossTypes "github.com/SigNoz/signoz/pkg/types"
-	"github.com/google/uuid"
-	"go.uber.org/zap"
-)
-
-// GetDomainFromSsoResponse uses relay state received from IdP to fetch
-// user domain. The domain is further used to process validity of the response.
-// when sending login request to IdP we send relay state as URL (site url)
-// with domainId or domainName as query parameter.
-func (m *modelDao) GetDomainFromSsoResponse(ctx context.Context, relayState *url.URL) (*types.GettableOrgDomain, error) {
-	// derive domain id from relay state now
-	var domainIdStr string
-	var domainNameStr string
-	var domain *types.GettableOrgDomain
-
-	for k, v := range relayState.Query() {
-		if k == "domainId" && len(v) > 0 {
-			domainIdStr = strings.Replace(v[0], ":", "-", -1)
-		}
-		if k == "domainName" && len(v) > 0 {
-			domainNameStr = v[0]
-		}
-	}
-
-	if domainIdStr != "" {
-		domainId, err := uuid.Parse(domainIdStr)
-		if err != nil {
-			zap.L().Error("failed to parse domainId from relay state", zap.Error(err))
-			return nil, fmt.Errorf("failed to parse domainId from IdP response")
-		}
-
-		domain, err = m.GetDomain(ctx, domainId)
-		if err != nil {
-			zap.L().Error("failed to find domain from domainId received in IdP response", zap.Error(err))
-			return nil, fmt.Errorf("invalid credentials")
-		}
-	}
-
-	if domainNameStr != "" {
-
-		domainFromDB, err := m.GetDomainByName(ctx, domainNameStr)
-		domain = domainFromDB
-		if err != nil {
-			zap.L().Error("failed to find domain from domainName received in IdP response", zap.Error(err))
-			return nil, fmt.Errorf("invalid credentials")
-		}
-	}
-	if domain != nil {
-		return domain, nil
-	}
-
-	return nil, fmt.Errorf("failed to find domain received in IdP response")
-}
-
-// GetDomainByName returns org domain for a given domain name
-func (m *modelDao) GetDomainByName(ctx context.Context, name string) (*types.GettableOrgDomain, basemodel.BaseApiError) {
-
-	stored := types.StorableOrgDomain{}
-	err := m.sqlStore.BunDB().NewSelect().
-		Model(&stored).
-		Where("name = ?", name).
-		Limit(1).
-		Scan(ctx)
-
-	if err != nil {
-		if err == sql.ErrNoRows {
-			return nil, model.BadRequest(fmt.Errorf("invalid domain name"))
-		}
-		return nil, model.InternalError(err)
-	}
-
-	domain := &types.GettableOrgDomain{StorableOrgDomain: stored}
-	if err := domain.LoadConfig(stored.Data); err != nil {
-		return nil, model.InternalError(err)
-	}
-	return domain, nil
-}
-
-// GetDomain returns org domain for a given domain id
-func (m *modelDao) GetDomain(ctx context.Context, id uuid.UUID) (*types.GettableOrgDomain, basemodel.BaseApiError) {
-
-	stored := types.StorableOrgDomain{}
-	err := m.sqlStore.BunDB().NewSelect().
-		Model(&stored).
-		Where("id = ?", id).
-		Limit(1).
-		Scan(ctx)
-
-	if err != nil {
-		if err == sql.ErrNoRows {
-			return nil, model.BadRequest(fmt.Errorf("invalid domain id"))
-		}
-		return nil, model.InternalError(err)
-	}
-
-	domain := &types.GettableOrgDomain{StorableOrgDomain: stored}
-	if err := domain.LoadConfig(stored.Data); err != nil {
-		return nil, model.InternalError(err)
-	}
-	return domain, nil
-}
-
-// ListDomains gets the list of auth domains by org id
-func (m *modelDao) ListDomains(ctx context.Context, orgId string) ([]types.GettableOrgDomain, basemodel.BaseApiError) {
-	domains := []types.GettableOrgDomain{}
-
-	stored := []types.StorableOrgDomain{}
-	err := m.sqlStore.BunDB().NewSelect().
-		Model(&stored).
-		Where("org_id = ?", orgId).
-		Scan(ctx)
-
-	if err != nil {
-		if err == sql.ErrNoRows {
-			return domains, nil
-		}
-		return nil, model.InternalError(err)
-	}
-
-	for _, s := range stored {
-		domain := types.GettableOrgDomain{StorableOrgDomain: s}
-		if err := domain.LoadConfig(s.Data); err != nil {
-			zap.L().Error("ListDomains() failed", zap.Error(err))
-		}
-		domains = append(domains, domain)
-	}
-
-	return domains, nil
-}
-
-// CreateDomain creates  a new auth domain
-func (m *modelDao) CreateDomain(ctx context.Context, domain *types.GettableOrgDomain) basemodel.BaseApiError {
-
-	if domain.ID == uuid.Nil {
-		domain.ID = uuid.New()
-	}
-
-	if domain.OrgID == "" || domain.Name == "" {
-		return model.BadRequest(fmt.Errorf("domain creation failed, missing fields: OrgID, Name "))
-	}
-
-	configJson, err := json.Marshal(domain)
-	if err != nil {
-		zap.L().Error("failed to unmarshal domain config", zap.Error(err))
-		return model.InternalError(fmt.Errorf("domain creation failed"))
-	}
-
-	storableDomain := types.StorableOrgDomain{
-		ID:            domain.ID,
-		Name:          domain.Name,
-		OrgID:         domain.OrgID,
-		Data:          string(configJson),
-		TimeAuditable: ossTypes.TimeAuditable{CreatedAt: time.Now(), UpdatedAt: time.Now()},
-	}
-
-	_, err = m.sqlStore.BunDB().NewInsert().
-		Model(&storableDomain).
-		Exec(ctx)
-
-	if err != nil {
-		zap.L().Error("failed to insert domain in db", zap.Error(err))
-		return model.InternalError(fmt.Errorf("domain creation failed"))
-	}
-
-	return nil
-}
-
-// UpdateDomain updates stored config params for a domain
-func (m *modelDao) UpdateDomain(ctx context.Context, domain *types.GettableOrgDomain) basemodel.BaseApiError {
-
-	if domain.ID == uuid.Nil {
-		zap.L().Error("domain update failed", zap.Error(fmt.Errorf("OrgDomain.Id is null")))
-		return model.InternalError(fmt.Errorf("domain update failed"))
-	}
-
-	configJson, err := json.Marshal(domain)
-	if err != nil {
-		zap.L().Error("domain update failed", zap.Error(err))
-		return model.InternalError(fmt.Errorf("domain update failed"))
-	}
-
-	storableDomain := &types.StorableOrgDomain{
-		ID:            domain.ID,
-		Name:          domain.Name,
-		OrgID:         domain.OrgID,
-		Data:          string(configJson),
-		TimeAuditable: ossTypes.TimeAuditable{UpdatedAt: time.Now()},
-	}
-
-	_, err = m.sqlStore.BunDB().NewUpdate().
-		Model(storableDomain).
-		Column("data", "updated_at").
-		WherePK().
-		Exec(ctx)
-
-	if err != nil {
-		zap.L().Error("domain update failed", zap.Error(err))
-		return model.InternalError(fmt.Errorf("domain update failed"))
-	}
-
-	return nil
-}
-
-// DeleteDomain deletes an org domain
-func (m *modelDao) DeleteDomain(ctx context.Context, id uuid.UUID) basemodel.BaseApiError {
-
-	if id == uuid.Nil {
-		zap.L().Error("domain delete failed", zap.Error(fmt.Errorf("OrgDomain.Id is null")))
-		return model.InternalError(fmt.Errorf("domain delete failed"))
-	}
-
-	storableDomain := &types.StorableOrgDomain{ID: id}
-	_, err := m.sqlStore.BunDB().NewDelete().
-		Model(storableDomain).
-		WherePK().
-		Exec(ctx)
-
-	if err != nil {
-		zap.L().Error("domain delete failed", zap.Error(err))
-		return model.InternalError(fmt.Errorf("domain delete failed"))
-	}
-
-	return nil
-}
-
-func (m *modelDao) GetDomainByEmail(ctx context.Context, email string) (*types.GettableOrgDomain, basemodel.BaseApiError) {
-
-	if email == "" {
-		return nil, model.BadRequest(fmt.Errorf("could not find auth domain, missing fields: email "))
-	}
-
-	components := strings.Split(email, "@")
-	if len(components) < 2 {
-		return nil, model.BadRequest(fmt.Errorf("invalid email address"))
-	}
-
-	parsedDomain := components[1]
-
-	stored := types.StorableOrgDomain{}
-	err := m.sqlStore.BunDB().NewSelect().
-		Model(&stored).
-		Where("name = ?", parsedDomain).
-		Limit(1).
-		Scan(ctx)
-
-	if err != nil {
-		if err == sql.ErrNoRows {
-			return nil, nil
-		}
-		return nil, model.InternalError(err)
-	}
-
-	domain := &types.GettableOrgDomain{StorableOrgDomain: stored}
-	if err := domain.LoadConfig(stored.Data); err != nil {
-		return nil, model.InternalError(err)
-	}
-	return domain, nil
-}

ee/query-service/dao/sqlite/modelDao.go

@@ -1,18 +0,0 @@
-package sqlite
-
-import (
-	"github.com/SigNoz/signoz/pkg/modules/user"
-	"github.com/SigNoz/signoz/pkg/modules/user/impluser"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-)
-
-type modelDao struct {
-	userModule user.Module
-	sqlStore   sqlstore.SQLStore
-}
-
-// InitDB creates and extends base model DB repository
-func NewModelDao(sqlStore sqlstore.SQLStore) *modelDao {
-	userModule := impluser.NewModule(impluser.NewStore(sqlStore))
-	return &modelDao{userModule: userModule, sqlStore: sqlStore}
-}

ee/query-service/dao/sqlite/pat.go

@@ -1,201 +0,0 @@
-package sqlite
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/SigNoz/signoz/ee/query-service/model"
-	"github.com/SigNoz/signoz/ee/types"
-	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
-	ossTypes "github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-
-	"go.uber.org/zap"
-)
-
-func (m *modelDao) CreatePAT(ctx context.Context, orgID string, p types.GettablePAT) (types.GettablePAT, basemodel.BaseApiError) {
-	p.StorablePersonalAccessToken.OrgID = orgID
-	p.StorablePersonalAccessToken.ID = valuer.GenerateUUID()
-	_, err := m.sqlStore.BunDB().NewInsert().
-		Model(&p.StorablePersonalAccessToken).
-		Exec(ctx)
-	if err != nil {
-		zap.L().Error("Failed to insert PAT in db, err: %v", zap.Error(err))
-		return types.GettablePAT{}, model.InternalError(fmt.Errorf("PAT insertion failed"))
-	}
-
-	createdByUser, _ := m.userModule.GetUserByID(ctx, orgID, p.UserID)
-	if createdByUser == nil {
-		p.CreatedByUser = types.PatUser{
-			NotFound: true,
-		}
-	} else {
-		p.CreatedByUser = types.PatUser{
-			User: ossTypes.User{
-				Identifiable: ossTypes.Identifiable{
-					ID: createdByUser.ID,
-				},
-				DisplayName: createdByUser.DisplayName,
-				Email:       createdByUser.Email,
-				TimeAuditable: ossTypes.TimeAuditable{
-					CreatedAt: createdByUser.CreatedAt,
-					UpdatedAt: createdByUser.UpdatedAt,
-				},
-			},
-			NotFound: false,
-		}
-	}
-	return p, nil
-}
-
-func (m *modelDao) UpdatePAT(ctx context.Context, orgID string, p types.GettablePAT, id valuer.UUID) basemodel.BaseApiError {
-	_, err := m.sqlStore.BunDB().NewUpdate().
-		Model(&p.StorablePersonalAccessToken).
-		Column("role", "name", "updated_at", "updated_by_user_id").
-		Where("id = ?", id.StringValue()).
-		Where("org_id = ?", orgID).
-		Where("revoked = false").
-		Exec(ctx)
-	if err != nil {
-		zap.L().Error("Failed to update PAT in db, err: %v", zap.Error(err))
-		return model.InternalError(fmt.Errorf("PAT update failed"))
-	}
-	return nil
-}
-
-func (m *modelDao) ListPATs(ctx context.Context, orgID string) ([]types.GettablePAT, basemodel.BaseApiError) {
-	pats := []types.StorablePersonalAccessToken{}
-
-	if err := m.sqlStore.BunDB().NewSelect().
-		Model(&pats).
-		Where("revoked = false").
-		Where("org_id = ?", orgID).
-		Order("updated_at DESC").
-		Scan(ctx); err != nil {
-		zap.L().Error("Failed to fetch PATs err: %v", zap.Error(err))
-		return nil, model.InternalError(fmt.Errorf("failed to fetch PATs"))
-	}
-
-	patsWithUsers := []types.GettablePAT{}
-	for i := range pats {
-		patWithUser := types.GettablePAT{
-			StorablePersonalAccessToken: pats[i],
-		}
-
-		createdByUser, _ := m.userModule.GetUserByID(ctx, orgID, pats[i].UserID)
-		if createdByUser == nil {
-			patWithUser.CreatedByUser = types.PatUser{
-				NotFound: true,
-			}
-		} else {
-			patWithUser.CreatedByUser = types.PatUser{
-				User: ossTypes.User{
-					Identifiable: ossTypes.Identifiable{
-						ID: createdByUser.ID,
-					},
-					DisplayName: createdByUser.DisplayName,
-					Email:       createdByUser.Email,
-					TimeAuditable: ossTypes.TimeAuditable{
-						CreatedAt: createdByUser.CreatedAt,
-						UpdatedAt: createdByUser.UpdatedAt,
-					},
-				},
-				NotFound: false,
-			}
-		}
-
-		updatedByUser, _ := m.userModule.GetUserByID(ctx, orgID, pats[i].UpdatedByUserID)
-		if updatedByUser == nil {
-			patWithUser.UpdatedByUser = types.PatUser{
-				NotFound: true,
-			}
-		} else {
-			patWithUser.UpdatedByUser = types.PatUser{
-				User: ossTypes.User{
-					Identifiable: ossTypes.Identifiable{
-						ID: updatedByUser.ID,
-					},
-					DisplayName: updatedByUser.DisplayName,
-					Email:       updatedByUser.Email,
-					TimeAuditable: ossTypes.TimeAuditable{
-						CreatedAt: updatedByUser.CreatedAt,
-						UpdatedAt: updatedByUser.UpdatedAt,
-					},
-				},
-				NotFound: false,
-			}
-		}
-
-		patsWithUsers = append(patsWithUsers, patWithUser)
-	}
-	return patsWithUsers, nil
-}
-
-func (m *modelDao) RevokePAT(ctx context.Context, orgID string, id valuer.UUID, userID string) basemodel.BaseApiError {
-	updatedAt := time.Now().Unix()
-	_, err := m.sqlStore.BunDB().NewUpdate().
-		Model(&types.StorablePersonalAccessToken{}).
-		Set("revoked = ?", true).
-		Set("updated_by_user_id = ?", userID).
-		Set("updated_at = ?", updatedAt).
-		Where("id = ?", id.StringValue()).
-		Where("org_id = ?", orgID).
-		Exec(ctx)
-	if err != nil {
-		zap.L().Error("Failed to revoke PAT in db, err: %v", zap.Error(err))
-		return model.InternalError(fmt.Errorf("PAT revoke failed"))
-	}
-	return nil
-}
-
-func (m *modelDao) GetPAT(ctx context.Context, token string) (*types.GettablePAT, basemodel.BaseApiError) {
-	pats := []types.StorablePersonalAccessToken{}
-
-	if err := m.sqlStore.BunDB().NewSelect().
-		Model(&pats).
-		Where("token = ?", token).
-		Where("revoked = false").
-		Scan(ctx); err != nil {
-		return nil, model.InternalError(fmt.Errorf("failed to fetch PAT"))
-	}
-
-	if len(pats) != 1 {
-		return nil, &model.ApiError{
-			Typ: model.ErrorInternal,
-			Err: fmt.Errorf("found zero or multiple PATs with same token, %s", token),
-		}
-	}
-
-	patWithUser := types.GettablePAT{
-		StorablePersonalAccessToken: pats[0],
-	}
-
-	return &patWithUser, nil
-}
-
-func (m *modelDao) GetPATByID(ctx context.Context, orgID string, id valuer.UUID) (*types.GettablePAT, basemodel.BaseApiError) {
-	pats := []types.StorablePersonalAccessToken{}
-
-	if err := m.sqlStore.BunDB().NewSelect().
-		Model(&pats).
-		Where("id = ?", id.StringValue()).
-		Where("org_id = ?", orgID).
-		Where("revoked = false").
-		Scan(ctx); err != nil {
-		return nil, model.InternalError(fmt.Errorf("failed to fetch PAT"))
-	}
-
-	if len(pats) != 1 {
-		return nil, &model.ApiError{
-			Typ: model.ErrorInternal,
-			Err: fmt.Errorf("found zero or multiple PATs with same token"),
-		}
-	}
-
-	patWithUser := types.GettablePAT{
-		StorablePersonalAccessToken: pats[0],
-	}
-
-	return &patWithUser, nil
-}

ee/query-service/integrations/signozio/signozio.go

@@ -1,67 +0,0 @@
-package signozio
-
-import (
-	"context"
-	"encoding/json"
-
-	"github.com/SigNoz/signoz/ee/query-service/model"
-	"github.com/SigNoz/signoz/pkg/zeus"
-	"github.com/tidwall/gjson"
-)
-
-func ValidateLicenseV3(ctx context.Context, licenseKey string, zeus zeus.Zeus) (*model.LicenseV3, error) {
-	data, err := zeus.GetLicense(ctx, licenseKey)
-	if err != nil {
-		return nil, err
-	}
-
-	var m map[string]any
-	if err = json.Unmarshal(data, &m); err != nil {
-		return nil, err
-	}
-
-	license, err := model.NewLicenseV3(m)
-	if err != nil {
-		return nil, err
-	}
-
-	return license, nil
-}
-
-// SendUsage reports the usage of signoz to license server
-func SendUsage(ctx context.Context, usage model.UsagePayload, zeus zeus.Zeus) error {
-	body, err := json.Marshal(usage)
-	if err != nil {
-		return err
-	}
-
-	return zeus.PutMeters(ctx, usage.LicenseKey.String(), body)
-}
-
-func CheckoutSession(ctx context.Context, checkoutRequest *model.CheckoutRequest, licenseKey string, zeus zeus.Zeus) (string, error) {
-	body, err := json.Marshal(checkoutRequest)
-	if err != nil {
-		return "", err
-	}
-
-	response, err := zeus.GetCheckoutURL(ctx, licenseKey, body)
-	if err != nil {
-		return "", err
-	}
-
-	return gjson.GetBytes(response, "url").String(), nil
-}
-
-func PortalSession(ctx context.Context, portalRequest *model.PortalRequest, licenseKey string, zeus zeus.Zeus) (string, error) {
-	body, err := json.Marshal(portalRequest)
-	if err != nil {
-		return "", err
-	}
-
-	response, err := zeus.GetPortalURL(ctx, licenseKey, body)
-	if err != nil {
-		return "", err
-	}
-
-	return gjson.GetBytes(response, "url").String(), nil
-}

ee/query-service/license/db.go

@@ -1,248 +0,0 @@
-package license
-
-import (
-	"context"
-	"database/sql"
-	"encoding/json"
-	"fmt"
-	"time"
-
-	"github.com/jmoiron/sqlx"
-	"github.com/mattn/go-sqlite3"
-
-	"github.com/SigNoz/signoz/ee/query-service/model"
-	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/types"
-	"go.uber.org/zap"
-)
-
-// Repo is license repo. stores license keys in a secured DB
-type Repo struct {
-	db    *sqlx.DB
-	store sqlstore.SQLStore
-}
-
-// NewLicenseRepo initiates a new license repo
-func NewLicenseRepo(db *sqlx.DB, store sqlstore.SQLStore) Repo {
-	return Repo{
-		db:    db,
-		store: store,
-	}
-}
-
-func (r *Repo) GetLicensesV3(ctx context.Context) ([]*model.LicenseV3, error) {
-	licensesData := []model.LicenseDB{}
-	licenseV3Data := []*model.LicenseV3{}
-
-	query := "SELECT id,key,data FROM licenses_v3"
-
-	err := r.db.Select(&licensesData, query)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get licenses from db: %v", err)
-	}
-
-	for _, l := range licensesData {
-		var licenseData map[string]interface{}
-		err := json.Unmarshal([]byte(l.Data), &licenseData)
-		if err != nil {
-			return nil, fmt.Errorf("failed to unmarshal data into licenseData : %v", err)
-		}
-
-		license, err := model.NewLicenseV3WithIDAndKey(l.ID, l.Key, licenseData)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get licenses v3 schema : %v", err)
-		}
-		licenseV3Data = append(licenseV3Data, license)
-	}
-
-	return licenseV3Data, nil
-}
-
-// GetActiveLicense fetches the latest active license from DB.
-// If the license is not present, expect a nil license and a nil error in the output.
-func (r *Repo) GetActiveLicense(ctx context.Context) (*model.License, *basemodel.ApiError) {
-	activeLicenseV3, err := r.GetActiveLicenseV3(ctx)
-	if err != nil {
-		return nil, basemodel.InternalError(fmt.Errorf("failed to get active licenses from db: %v", err))
-	}
-
-	if activeLicenseV3 == nil {
-		return nil, nil
-	}
-	activeLicenseV2 := model.ConvertLicenseV3ToLicenseV2(activeLicenseV3)
-	return activeLicenseV2, nil
-}
-
-func (r *Repo) GetActiveLicenseV3(ctx context.Context) (*model.LicenseV3, error) {
-	var err error
-	licenses := []model.LicenseDB{}
-
-	query := "SELECT id,key,data FROM licenses_v3"
-
-	err = r.db.Select(&licenses, query)
-	if err != nil {
-		return nil, basemodel.InternalError(fmt.Errorf("failed to get active licenses from db: %v", err))
-	}
-
-	var active *model.LicenseV3
-	for _, l := range licenses {
-		var licenseData map[string]interface{}
-		err := json.Unmarshal([]byte(l.Data), &licenseData)
-		if err != nil {
-			return nil, fmt.Errorf("failed to unmarshal data into licenseData : %v", err)
-		}
-
-		license, err := model.NewLicenseV3WithIDAndKey(l.ID, l.Key, licenseData)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get licenses v3 schema : %v", err)
-		}
-
-		if active == nil &&
-			(license.ValidFrom != 0) &&
-			(license.ValidUntil == -1 || license.ValidUntil > time.Now().Unix()) {
-			active = license
-		}
-		if active != nil &&
-			license.ValidFrom > active.ValidFrom &&
-			(license.ValidUntil == -1 || license.ValidUntil > time.Now().Unix()) {
-			active = license
-		}
-	}
-
-	return active, nil
-}
-
-// InsertLicenseV3 inserts a new license v3 in db
-func (r *Repo) InsertLicenseV3(ctx context.Context, l *model.LicenseV3) *model.ApiError {
-
-	query := `INSERT INTO licenses_v3 (id, key, data) VALUES ($1, $2, $3)`
-
-	// licsense is the entity of zeus so putting the entire license here without defining schema
-	licenseData, err := json.Marshal(l.Data)
-	if err != nil {
-		return &model.ApiError{Typ: basemodel.ErrorBadData, Err: err}
-	}
-
-	_, err = r.db.ExecContext(ctx,
-		query,
-		l.ID,
-		l.Key,
-		string(licenseData),
-	)
-
-	if err != nil {
-		if sqliteErr, ok := err.(sqlite3.Error); ok {
-			if sqliteErr.ExtendedCode == sqlite3.ErrConstraintUnique {
-				zap.L().Error("error in inserting license data: ", zap.Error(sqliteErr))
-				return &model.ApiError{Typ: model.ErrorConflict, Err: sqliteErr}
-			}
-		}
-		zap.L().Error("error in inserting license data: ", zap.Error(err))
-		return &model.ApiError{Typ: basemodel.ErrorExec, Err: err}
-	}
-
-	return nil
-}
-
-// UpdateLicenseV3 updates a new license v3 in db
-func (r *Repo) UpdateLicenseV3(ctx context.Context, l *model.LicenseV3) error {
-
-	// the key and id for the license can't change so only update the data here!
-	query := `UPDATE licenses_v3 SET data=$1 WHERE id=$2;`
-
-	license, err := json.Marshal(l.Data)
-	if err != nil {
-		return fmt.Errorf("insert license failed: license marshal error")
-	}
-	_, err = r.db.ExecContext(ctx,
-		query,
-		license,
-		l.ID,
-	)
-
-	if err != nil {
-		zap.L().Error("error in updating license data: ", zap.Error(err))
-		return fmt.Errorf("failed to update license in db: %v", err)
-	}
-
-	return nil
-}
-
-func (r *Repo) CreateFeature(req *types.FeatureStatus) *basemodel.ApiError {
-
-	_, err := r.store.BunDB().NewInsert().
-		Model(req).
-		Exec(context.Background())
-	if err != nil {
-		return &basemodel.ApiError{Typ: basemodel.ErrorInternal, Err: err}
-	}
-	return nil
-}
-
-func (r *Repo) GetFeature(featureName string) (types.FeatureStatus, error) {
-	var feature types.FeatureStatus
-
-	err := r.store.BunDB().NewSelect().
-		Model(&feature).
-		Where("name = ?", featureName).
-		Scan(context.Background())
-
-	if err != nil {
-		return feature, err
-	}
-	if feature.Name == "" {
-		return feature, basemodel.ErrFeatureUnavailable{Key: featureName}
-	}
-	return feature, nil
-}
-
-func (r *Repo) GetAllFeatures() ([]basemodel.Feature, error) {
-
-	var feature []basemodel.Feature
-
-	err := r.db.Select(&feature,
-		`SELECT * FROM feature_status;`)
-	if err != nil {
-		return feature, err
-	}
-
-	return feature, nil
-}
-
-func (r *Repo) UpdateFeature(req types.FeatureStatus) error {
-
-	_, err := r.store.BunDB().NewUpdate().
-		Model(&req).
-		Where("name = ?", req.Name).
-		Exec(context.Background())
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (r *Repo) InitFeatures(req []types.FeatureStatus) error {
-	// get a feature by name, if it doesn't exist, create it. If it does exist, update it.
-	for _, feature := range req {
-		currentFeature, err := r.GetFeature(feature.Name)
-		if err != nil && err == sql.ErrNoRows {
-			err := r.CreateFeature(&feature)
-			if err != nil {
-				return err
-			}
-			continue
-		} else if err != nil {
-			return err
-		}
-		feature.Usage = int(currentFeature.Usage)
-		if feature.Usage >= feature.UsageLimit && feature.UsageLimit != -1 {
-			feature.Active = false
-		}
-		err = r.UpdateFeature(feature)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}

ee/query-service/license/manager.go

@@ -1,318 +0,0 @@
-package license
-
-import (
-	"context"
-	"sync/atomic"
-	"time"
-
-	"github.com/jmoiron/sqlx"
-
-	"sync"
-
-	baseconstants "github.com/SigNoz/signoz/pkg/query-service/constants"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/zeus"
-
-	validate "github.com/SigNoz/signoz/ee/query-service/integrations/signozio"
-	"github.com/SigNoz/signoz/ee/query-service/model"
-	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
-	"github.com/SigNoz/signoz/pkg/query-service/telemetry"
-	"go.uber.org/zap"
-)
-
-var LM *Manager
-
-// validate and update license every 24 hours
-var validationFrequency = 24 * 60 * time.Minute
-
-type Manager struct {
-	repo             *Repo
-	zeus             zeus.Zeus
-	mutex            sync.Mutex
-	validatorRunning bool
-	// end the license validation, this is important to gracefully
-	// stopping validation and protect in-consistent updates
-	done chan struct{}
-	// terminated waits for the validate go routine to end
-	terminated chan struct{}
-	// last time the license was validated
-	lastValidated int64
-	// keep track of validation failure attempts
-	failedAttempts uint64
-	// keep track of active license and features
-	activeLicenseV3 *model.LicenseV3
-	activeFeatures  basemodel.FeatureSet
-}
-
-func StartManager(db *sqlx.DB, store sqlstore.SQLStore, zeus zeus.Zeus, features ...basemodel.Feature) (*Manager, error) {
-	if LM != nil {
-		return LM, nil
-	}
-
-	repo := NewLicenseRepo(db, store)
-	m := &Manager{
-		repo: &repo,
-		zeus: zeus,
-	}
-	if err := m.start(features...); err != nil {
-		return m, err
-	}
-
-	LM = m
-	return m, nil
-}
-
-// start loads active license in memory and initiates validator
-func (lm *Manager) start(features ...basemodel.Feature) error {
-	return lm.LoadActiveLicenseV3(features...)
-}
-
-func (lm *Manager) Stop() {
-	close(lm.done)
-	<-lm.terminated
-}
-
-func (lm *Manager) SetActiveV3(l *model.LicenseV3, features ...basemodel.Feature) {
-	lm.mutex.Lock()
-	defer lm.mutex.Unlock()
-
-	if l == nil {
-		return
-	}
-
-	lm.activeLicenseV3 = l
-	lm.activeFeatures = append(l.Features, features...)
-	// set default features
-	setDefaultFeatures(lm)
-
-	err := lm.InitFeatures(lm.activeFeatures)
-	if err != nil {
-		zap.L().Panic("Couldn't activate features", zap.Error(err))
-	}
-	if !lm.validatorRunning {
-		// we want to make sure only one validator runs,
-		// we already have lock() so good to go
-		lm.validatorRunning = true
-		go lm.ValidatorV3(context.Background())
-	}
-
-}
-
-func setDefaultFeatures(lm *Manager) {
-	lm.activeFeatures = append(lm.activeFeatures, baseconstants.DEFAULT_FEATURE_SET...)
-}
-
-func (lm *Manager) LoadActiveLicenseV3(features ...basemodel.Feature) error {
-	active, err := lm.repo.GetActiveLicenseV3(context.Background())
-	if err != nil {
-		return err
-	}
-
-	if active != nil {
-		lm.SetActiveV3(active, features...)
-	} else {
-		zap.L().Info("No active license found, defaulting to basic plan")
-		// if no active license is found, we default to basic(free) plan with all default features
-		lm.activeFeatures = model.BasicPlan
-		setDefaultFeatures(lm)
-		err := lm.InitFeatures(lm.activeFeatures)
-		if err != nil {
-			zap.L().Error("Couldn't initialize features", zap.Error(err))
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (lm *Manager) GetLicensesV3(ctx context.Context) (response []*model.LicenseV3, apiError *model.ApiError) {
-
-	licenses, err := lm.repo.GetLicensesV3(ctx)
-	if err != nil {
-		return nil, model.InternalError(err)
-	}
-
-	for _, l := range licenses {
-		if lm.activeLicenseV3 != nil && l.Key == lm.activeLicenseV3.Key {
-			l.IsCurrent = true
-		}
-		if l.ValidUntil == -1 {
-			// for subscriptions, there is no end-date as such
-			// but for showing user some validity we default one year timespan
-			l.ValidUntil = l.ValidFrom + 31556926
-		}
-		response = append(response, l)
-	}
-
-	return response, nil
-}
-
-// Validator validates license after an epoch of time
-func (lm *Manager) ValidatorV3(ctx context.Context) {
-	zap.L().Info("ValidatorV3 started!")
-	defer close(lm.terminated)
-
-	tick := time.NewTicker(validationFrequency)
-	defer tick.Stop()
-
-	_ = lm.ValidateV3(ctx)
-	for {
-		select {
-		case <-lm.done:
-			return
-		default:
-			select {
-			case <-lm.done:
-				return
-			case <-tick.C:
-				_ = lm.ValidateV3(ctx)
-			}
-		}
-
-	}
-}
-
-func (lm *Manager) RefreshLicense(ctx context.Context) error {
-	license, err := validate.ValidateLicenseV3(ctx, lm.activeLicenseV3.Key, lm.zeus)
-	if err != nil {
-		return err
-	}
-
-	err = lm.repo.UpdateLicenseV3(ctx, license)
-	if err != nil {
-		return err
-	}
-	lm.SetActiveV3(license)
-
-	return nil
-}
-
-func (lm *Manager) ValidateV3(ctx context.Context) (reterr error) {
-	if lm.activeLicenseV3 == nil {
-		return nil
-	}
-
-	defer func() {
-		lm.mutex.Lock()
-
-		lm.lastValidated = time.Now().Unix()
-		if reterr != nil {
-			zap.L().Error("License validation completed with error", zap.Error(reterr))
-
-			atomic.AddUint64(&lm.failedAttempts, 1)
-			// default to basic plan if validation fails for three consecutive times
-			if atomic.LoadUint64(&lm.failedAttempts) > 3 {
-				zap.L().Error("License validation completed with error for three consecutive times, defaulting to basic plan", zap.String("license_id", lm.activeLicenseV3.ID), zap.Bool("license_validation", false))
-				lm.activeLicenseV3 = nil
-				lm.activeFeatures = model.BasicPlan
-				setDefaultFeatures(lm)
-				err := lm.InitFeatures(lm.activeFeatures)
-				if err != nil {
-					zap.L().Error("Couldn't initialize features", zap.Error(err))
-				}
-				lm.done <- struct{}{}
-				lm.validatorRunning = false
-			}
-
-			telemetry.GetInstance().SendEvent(telemetry.TELEMETRY_LICENSE_CHECK_FAILED,
-				map[string]interface{}{"err": reterr.Error()}, "", true, false)
-		} else {
-			// reset the failed attempts counter
-			atomic.StoreUint64(&lm.failedAttempts, 0)
-			zap.L().Info("License validation completed with no errors")
-		}
-
-		lm.mutex.Unlock()
-	}()
-
-	err := lm.RefreshLicense(ctx)
-
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (lm *Manager) ActivateV3(ctx context.Context, licenseKey string) (*model.LicenseV3, error) {
-	license, err := validate.ValidateLicenseV3(ctx, licenseKey, lm.zeus)
-	if err != nil {
-		return nil, err
-	}
-
-	// insert the new license to the sqlite db
-	modelErr := lm.repo.InsertLicenseV3(ctx, license)
-	if modelErr != nil {
-		zap.L().Error("failed to activate license", zap.Error(modelErr))
-		return nil, modelErr
-	}
-
-	// license is valid, activate it
-	lm.SetActiveV3(license)
-	return license, nil
-}
-
-func (lm *Manager) GetActiveLicense() *model.LicenseV3 {
-	return lm.activeLicenseV3
-}
-
-// CheckFeature will be internally used by backend routines
-// for feature gating
-func (lm *Manager) CheckFeature(featureKey string) error {
-	feature, err := lm.repo.GetFeature(featureKey)
-	if err != nil {
-		return err
-	}
-	if feature.Active {
-		return nil
-	}
-	return basemodel.ErrFeatureUnavailable{Key: featureKey}
-}
-
-// GetFeatureFlags returns current active features
-func (lm *Manager) GetFeatureFlags() (basemodel.FeatureSet, error) {
-	return lm.repo.GetAllFeatures()
-}
-
-func (lm *Manager) InitFeatures(features basemodel.FeatureSet) error {
-	featureStatus := make([]types.FeatureStatus, len(features))
-	for i, f := range features {
-		featureStatus[i] = types.FeatureStatus{
-			Name:       f.Name,
-			Active:     f.Active,
-			Usage:      int(f.Usage),
-			UsageLimit: int(f.UsageLimit),
-			Route:      f.Route,
-		}
-	}
-	return lm.repo.InitFeatures(featureStatus)
-}
-
-func (lm *Manager) UpdateFeatureFlag(feature basemodel.Feature) error {
-	return lm.repo.UpdateFeature(types.FeatureStatus{
-		Name:       feature.Name,
-		Active:     feature.Active,
-		Usage:      int(feature.Usage),
-		UsageLimit: int(feature.UsageLimit),
-		Route:      feature.Route,
-	})
-}
-
-func (lm *Manager) GetFeatureFlag(key string) (basemodel.Feature, error) {
-	featureStatus, err := lm.repo.GetFeature(key)
-	if err != nil {
-		return basemodel.Feature{}, err
-	}
-	return basemodel.Feature{
-		Name:       featureStatus.Name,
-		Active:     featureStatus.Active,
-		Usage:      int64(featureStatus.Usage),
-		UsageLimit: int64(featureStatus.UsageLimit),
-		Route:      featureStatus.Route,
-	}, nil
-}
-
-// GetRepo return the license repo
-func (lm *Manager) GetRepo() *Repo {
-	return lm.repo
-}

ee/query-service/main.go

@@ -6,7 +6,8 @@ import (
 	"os"
 	"time"
 
-	eeuserimpl "github.com/SigNoz/signoz/ee/modules/user/impluser"
+	"github.com/SigNoz/signoz/ee/licensing"
+	"github.com/SigNoz/signoz/ee/licensing/httplicensing"
 	"github.com/SigNoz/signoz/ee/query-service/app"
 	"github.com/SigNoz/signoz/ee/sqlstore/postgressqlstore"
 	"github.com/SigNoz/signoz/ee/zeus"
@@ -14,13 +15,15 @@ import (
 	"github.com/SigNoz/signoz/pkg/config"
 	"github.com/SigNoz/signoz/pkg/config/envprovider"
 	"github.com/SigNoz/signoz/pkg/config/fileprovider"
-	"github.com/SigNoz/signoz/pkg/modules/user"
+	"github.com/SigNoz/signoz/pkg/factory"
+	pkglicensing "github.com/SigNoz/signoz/pkg/licensing"
 	baseconst "github.com/SigNoz/signoz/pkg/query-service/constants"
 	"github.com/SigNoz/signoz/pkg/signoz"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/sqlstore/sqlstorehook"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/version"
+	pkgzeus "github.com/SigNoz/signoz/pkg/zeus"
 
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
@@ -88,8 +91,9 @@ func main() {
 	loggerMgr := initZapLog()
 	zap.ReplaceGlobals(loggerMgr)
 	defer loggerMgr.Sync() // flushes buffer, if any
+	ctx := context.Background()
 
-	config, err := signoz.NewConfig(context.Background(), config.ResolverConfig{
+	config, err := signoz.NewConfig(ctx, config.ResolverConfig{
 		Uris: []string{"env:"},
 		ProviderFactories: []config.ProviderFactory{
 			envprovider.NewFactory(),
@@ -112,26 +116,6 @@ func main() {
 		zap.L().Fatal("Failed to add postgressqlstore factory", zap.Error(err))
 	}
 
-	signoz, err := signoz.New(
-		context.Background(),
-		config,
-		zeus.Config(),
-		httpzeus.NewProviderFactory(),
-		signoz.NewCacheProviderFactories(),
-		signoz.NewWebProviderFactories(),
-		sqlStoreFactories,
-		signoz.NewTelemetryStoreProviderFactories(),
-		func(sqlstore sqlstore.SQLStore) user.Module {
-			return eeuserimpl.NewModule(eeuserimpl.NewStore(sqlstore))
-		},
-		func(userModule user.Module) user.Handler {
-			return eeuserimpl.NewHandler(userModule)
-		},
-	)
-	if err != nil {
-		zap.L().Fatal("Failed to create signoz", zap.Error(err))
-	}
-
 	jwtSecret := os.Getenv("SIGNOZ_JWT_SECRET")
 
 	if len(jwtSecret) == 0 {
@@ -142,6 +126,26 @@ func main() {
 
 	jwt := authtypes.NewJWT(jwtSecret, 30*time.Minute, 30*24*time.Hour)
 
+	signoz, err := signoz.New(
+		context.Background(),
+		config,
+		jwt,
+		zeus.Config(),
+		httpzeus.NewProviderFactory(),
+		licensing.Config(24*time.Hour, 3),
+		func(sqlstore sqlstore.SQLStore, zeus pkgzeus.Zeus) factory.ProviderFactory[pkglicensing.Licensing, pkglicensing.Config] {
+			return httplicensing.NewProviderFactory(sqlstore, zeus)
+		},
+		signoz.NewEmailingProviderFactories(),
+		signoz.NewCacheProviderFactories(),
+		signoz.NewWebProviderFactories(),
+		sqlStoreFactories,
+		signoz.NewTelemetryStoreProviderFactories(),
+	)
+	if err != nil {
+		zap.L().Fatal("Failed to create signoz", zap.Error(err))
+	}
+
 	serverOptions := &app.ServerOptions{
 		Config:                     config,
 		SigNoz:                     signoz,
@@ -160,22 +164,22 @@ func main() {
 		zap.L().Fatal("Failed to create server", zap.Error(err))
 	}
 
-	if err := server.Start(context.Background()); err != nil {
+	if err := server.Start(ctx); err != nil {
 		zap.L().Fatal("Could not start server", zap.Error(err))
 	}
 
-	signoz.Start(context.Background())
+	signoz.Start(ctx)
 
-	if err := signoz.Wait(context.Background()); err != nil {
+	if err := signoz.Wait(ctx); err != nil {
 		zap.L().Fatal("Failed to start signoz", zap.Error(err))
 	}
 
-	err = server.Stop()
+	err = server.Stop(ctx)
 	if err != nil {
 		zap.L().Fatal("Failed to stop server", zap.Error(err))
 	}
 
-	err = signoz.Stop(context.Background())
+	err = signoz.Stop(ctx)
 	if err != nil {
 		zap.L().Fatal("Failed to stop signoz", zap.Error(err))
 	}

ee/query-service/model/license.go

@@ -1,244 +0,0 @@
-package model
-
-import (
-	"encoding/json"
-	"fmt"
-	"reflect"
-	"time"
-
-	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
-	"github.com/pkg/errors"
-)
-
-type License struct {
-	Key          string    `json:"key" db:"key"`
-	ActivationId string    `json:"activationId" db:"activationId"`
-	CreatedAt    time.Time `db:"created_at"`
-
-	// PlanDetails contains the encrypted plan info
-	PlanDetails string `json:"planDetails" db:"planDetails"`
-
-	// stores parsed license details
-	LicensePlan
-
-	FeatureSet basemodel.FeatureSet
-
-	// populated in case license has any errors
-	ValidationMessage string `db:"validationMessage"`
-
-	// used only for sending details to front-end
-	IsCurrent bool `json:"isCurrent"`
-}
-
-func (l *License) MarshalJSON() ([]byte, error) {
-
-	return json.Marshal(&struct {
-		Key               string    `json:"key" db:"key"`
-		ActivationId      string    `json:"activationId" db:"activationId"`
-		ValidationMessage string    `db:"validationMessage"`
-		IsCurrent         bool      `json:"isCurrent"`
-		PlanKey           string    `json:"planKey"`
-		ValidFrom         time.Time `json:"ValidFrom"`
-		ValidUntil        time.Time `json:"ValidUntil"`
-		Status            string    `json:"status"`
-	}{
-		Key:               l.Key,
-		ActivationId:      l.ActivationId,
-		IsCurrent:         l.IsCurrent,
-		PlanKey:           l.PlanKey,
-		ValidFrom:         time.Unix(l.ValidFrom, 0),
-		ValidUntil:        time.Unix(l.ValidUntil, 0),
-		Status:            l.Status,
-		ValidationMessage: l.ValidationMessage,
-	})
-}
-
-type LicensePlan struct {
-	PlanKey    string `json:"planKey"`
-	ValidFrom  int64  `json:"validFrom"`
-	ValidUntil int64  `json:"validUntil"`
-	Status     string `json:"status"`
-}
-
-type Licenses struct {
-	TrialStart                   int64     `json:"trialStart"`
-	TrialEnd                     int64     `json:"trialEnd"`
-	OnTrial                      bool      `json:"onTrial"`
-	WorkSpaceBlock               bool      `json:"workSpaceBlock"`
-	TrialConvertedToSubscription bool      `json:"trialConvertedToSubscription"`
-	GracePeriodEnd               int64     `json:"gracePeriodEnd"`
-	Licenses                     []License `json:"licenses"`
-}
-
-type SubscriptionServerResp struct {
-	Status string   `json:"status"`
-	Data   Licenses `json:"data"`
-}
-
-type Plan struct {
-	Name string `json:"name"`
-}
-
-type LicenseDB struct {
-	ID   string `json:"id"`
-	Key  string `json:"key"`
-	Data string `json:"data"`
-}
-type LicenseV3 struct {
-	ID         string
-	Key        string
-	Data       map[string]interface{}
-	PlanName   string
-	Features   basemodel.FeatureSet
-	Status     string
-	IsCurrent  bool
-	ValidFrom  int64
-	ValidUntil int64
-}
-
-func extractKeyFromMapStringInterface[T any](data map[string]interface{}, key string) (T, error) {
-	var zeroValue T
-	if val, ok := data[key]; ok {
-		if value, ok := val.(T); ok {
-			return value, nil
-		}
-		return zeroValue, fmt.Errorf("%s key is not a valid %s", key, reflect.TypeOf(zeroValue))
-	}
-	return zeroValue, fmt.Errorf("%s key is missing", key)
-}
-
-func NewLicenseV3(data map[string]interface{}) (*LicenseV3, error) {
-	var features basemodel.FeatureSet
-
-	// extract id from data
-	licenseID, err := extractKeyFromMapStringInterface[string](data, "id")
-	if err != nil {
-		return nil, err
-	}
-	delete(data, "id")
-
-	// extract key from data
-	licenseKey, err := extractKeyFromMapStringInterface[string](data, "key")
-	if err != nil {
-		return nil, err
-	}
-	delete(data, "key")
-
-	// extract status from data
-	status, err := extractKeyFromMapStringInterface[string](data, "status")
-	if err != nil {
-		return nil, err
-	}
-
-	planMap, err := extractKeyFromMapStringInterface[map[string]any](data, "plan")
-	if err != nil {
-		return nil, err
-	}
-
-	planName, err := extractKeyFromMapStringInterface[string](planMap, "name")
-	if err != nil {
-		return nil, err
-	}
-	// if license status is invalid then default it to basic
-	if status == LicenseStatusInvalid {
-		planName = PlanNameBasic
-	}
-
-	featuresFromZeus := basemodel.FeatureSet{}
-	if _features, ok := data["features"]; ok {
-		featuresData, err := json.Marshal(_features)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to marshal features data")
-		}
-
-		if err := json.Unmarshal(featuresData, &featuresFromZeus); err != nil {
-			return nil, errors.Wrap(err, "failed to unmarshal features data")
-		}
-	}
-
-	switch planName {
-	case PlanNameEnterprise:
-		features = append(features, EnterprisePlan...)
-	case PlanNameBasic:
-		features = append(features, BasicPlan...)
-	default:
-		features = append(features, BasicPlan...)
-	}
-
-	if len(featuresFromZeus) > 0 {
-		for _, feature := range featuresFromZeus {
-			exists := false
-			for i, existingFeature := range features {
-				if existingFeature.Name == feature.Name {
-					features[i] = feature // Replace existing feature
-					exists = true
-					break
-				}
-			}
-			if !exists {
-				features = append(features, feature) // Append if it doesn't exist
-			}
-		}
-	}
-	data["features"] = features
-
-	_validFrom, err := extractKeyFromMapStringInterface[float64](data, "valid_from")
-	if err != nil {
-		_validFrom = 0
-	}
-	validFrom := int64(_validFrom)
-
-	_validUntil, err := extractKeyFromMapStringInterface[float64](data, "valid_until")
-	if err != nil {
-		_validUntil = 0
-	}
-	validUntil := int64(_validUntil)
-
-	return &LicenseV3{
-		ID:         licenseID,
-		Key:        licenseKey,
-		Data:       data,
-		PlanName:   planName,
-		Features:   features,
-		ValidFrom:  validFrom,
-		ValidUntil: validUntil,
-		Status:     status,
-	}, nil
-
-}
-
-func NewLicenseV3WithIDAndKey(id string, key string, data map[string]interface{}) (*LicenseV3, error) {
-	licenseDataWithIdAndKey := data
-	licenseDataWithIdAndKey["id"] = id
-	licenseDataWithIdAndKey["key"] = key
-	return NewLicenseV3(licenseDataWithIdAndKey)
-}
-
-func ConvertLicenseV3ToLicenseV2(l *LicenseV3) *License {
-	planKeyFromPlanName, ok := MapOldPlanKeyToNewPlanName[l.PlanName]
-	if !ok {
-		planKeyFromPlanName = Basic
-	}
-	return &License{
-		Key:               l.Key,
-		ActivationId:      "",
-		PlanDetails:       "",
-		FeatureSet:        l.Features,
-		ValidationMessage: "",
-		IsCurrent:         l.IsCurrent,
-		LicensePlan: LicensePlan{
-			PlanKey:    planKeyFromPlanName,
-			ValidFrom:  l.ValidFrom,
-			ValidUntil: l.ValidUntil,
-			Status:     l.Status},
-	}
-
-}
-
-type CheckoutRequest struct {
-	SuccessURL string `json:"url"`
-}
-
-type PortalRequest struct {
-	SuccessURL string `json:"url"`
-}

ee/query-service/model/license_test.go

@@ -1,170 +0,0 @@
-package model
-
-import (
-	"encoding/json"
-	"testing"
-
-	"github.com/SigNoz/signoz/pkg/query-service/model"
-	"github.com/pkg/errors"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestNewLicenseV3(t *testing.T) {
-	testCases := []struct {
-		name     string
-		data     []byte
-		pass     bool
-		expected *LicenseV3
-		error    error
-	}{
-		{
-			name:  "Error for missing license id",
-			data:  []byte(`{}`),
-			pass:  false,
-			error: errors.New("id key is missing"),
-		},
-		{
-			name:  "Error for license id not being a valid string",
-			data:  []byte(`{"id": 10}`),
-			pass:  false,
-			error: errors.New("id key is not a valid string"),
-		},
-		{
-			name:  "Error for missing license key",
-			data:  []byte(`{"id":"does-not-matter"}`),
-			pass:  false,
-			error: errors.New("key key is missing"),
-		},
-		{
-			name:  "Error for invalid string license key",
-			data:  []byte(`{"id":"does-not-matter","key":10}`),
-			pass:  false,
-			error: errors.New("key key is not a valid string"),
-		},
-		{
-			name:  "Error for missing license status",
-			data:  []byte(`{"id":"does-not-matter", "key": "does-not-matter","category":"FREE"}`),
-			pass:  false,
-			error: errors.New("status key is missing"),
-		},
-		{
-			name:  "Error for invalid string license status",
-			data:  []byte(`{"id":"does-not-matter","key": "does-not-matter", "category":"FREE", "status":10}`),
-			pass:  false,
-			error: errors.New("status key is not a valid string"),
-		},
-		{
-			name:  "Error for missing license plan",
-			data:  []byte(`{"id":"does-not-matter","key":"does-not-matter-key","category":"FREE","status":"ACTIVE"}`),
-			pass:  false,
-			error: errors.New("plan key is missing"),
-		},
-		{
-			name:  "Error for invalid json license plan",
-			data:  []byte(`{"id":"does-not-matter","key":"does-not-matter-key","category":"FREE","status":"ACTIVE","plan":10}`),
-			pass:  false,
-			error: errors.New("plan key is not a valid map[string]interface {}"),
-		},
-		{
-			name:  "Error for invalid license plan",
-			data:  []byte(`{"id":"does-not-matter","key":"does-not-matter-key","category":"FREE","status":"ACTIVE","plan":{}}`),
-			pass:  false,
-			error: errors.New("name key is missing"),
-		},
-		{
-			name: "Parse the entire license properly",
-			data: []byte(`{"id":"does-not-matter","key":"does-not-matter-key","category":"FREE","status":"ACTIVE","plan":{"name":"ENTERPRISE"},"valid_from": 1730899309,"valid_until": -1}`),
-			pass: true,
-			expected: &LicenseV3{
-				ID:  "does-not-matter",
-				Key: "does-not-matter-key",
-				Data: map[string]interface{}{
-					"plan": map[string]interface{}{
-						"name": "ENTERPRISE",
-					},
-					"category":    "FREE",
-					"status":      "ACTIVE",
-					"valid_from":  float64(1730899309),
-					"valid_until": float64(-1),
-				},
-				PlanName:   PlanNameEnterprise,
-				ValidFrom:  1730899309,
-				ValidUntil: -1,
-				Status:     "ACTIVE",
-				IsCurrent:  false,
-				Features:   model.FeatureSet{},
-			},
-		},
-		{
-			name: "Fallback to basic plan if license status is invalid",
-			data: []byte(`{"id":"does-not-matter","key":"does-not-matter-key","category":"FREE","status":"INVALID","plan":{"name":"ENTERPRISE"},"valid_from": 1730899309,"valid_until": -1}`),
-			pass: true,
-			expected: &LicenseV3{
-				ID:  "does-not-matter",
-				Key: "does-not-matter-key",
-				Data: map[string]interface{}{
-					"plan": map[string]interface{}{
-						"name": "ENTERPRISE",
-					},
-					"category":    "FREE",
-					"status":      "INVALID",
-					"valid_from":  float64(1730899309),
-					"valid_until": float64(-1),
-				},
-				PlanName:   PlanNameBasic,
-				ValidFrom:  1730899309,
-				ValidUntil: -1,
-				Status:     "INVALID",
-				IsCurrent:  false,
-				Features:   model.FeatureSet{},
-			},
-		},
-		{
-			name: "fallback states for validFrom and validUntil",
-			data: []byte(`{"id":"does-not-matter","key":"does-not-matter-key","category":"FREE","status":"ACTIVE","plan":{"name":"ENTERPRISE"},"valid_from":1234.456,"valid_until":5678.567}`),
-			pass: true,
-			expected: &LicenseV3{
-				ID:  "does-not-matter",
-				Key: "does-not-matter-key",
-				Data: map[string]interface{}{
-					"plan": map[string]interface{}{
-						"name": "ENTERPRISE",
-					},
-					"valid_from":  1234.456,
-					"valid_until": 5678.567,
-					"category":    "FREE",
-					"status":      "ACTIVE",
-				},
-				PlanName:   PlanNameEnterprise,
-				ValidFrom:  1234,
-				ValidUntil: 5678,
-				Status:     "ACTIVE",
-				IsCurrent:  false,
-				Features:   model.FeatureSet{},
-			},
-		},
-	}
-
-	for _, tc := range testCases {
-		var licensePayload map[string]interface{}
-		err := json.Unmarshal(tc.data, &licensePayload)
-		require.NoError(t, err)
-		license, err := NewLicenseV3(licensePayload)
-		if license != nil {
-			license.Features = make(model.FeatureSet, 0)
-			delete(license.Data, "features")
-		}
-
-		if tc.pass {
-			require.NoError(t, err)
-			require.NotNil(t, license)
-			assert.Equal(t, tc.expected, license)
-		} else {
-			require.Error(t, err)
-			assert.EqualError(t, err, tc.error.Error())
-			require.Nil(t, license)
-		}
-
-	}
-}

ee/query-service/model/pat.go

@@ -1,7 +0,0 @@
-package model
-
-type CreatePATRequestBody struct {
-	Name          string `json:"name"`
-	Role          string `json:"role"`
-	ExpiresInDays int64  `json:"expiresInDays"`
-}

ee/query-service/usage/manager.go

@@ -14,9 +14,9 @@ import (
 
 	"go.uber.org/zap"
 
-	"github.com/SigNoz/signoz/ee/query-service/dao"
-	"github.com/SigNoz/signoz/ee/query-service/license"
 	"github.com/SigNoz/signoz/ee/query-service/model"
+	"github.com/SigNoz/signoz/pkg/licensing"
+	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/query-service/utils/encryption"
 	"github.com/SigNoz/signoz/pkg/zeus"
 )
@@ -35,64 +35,69 @@ var (
 type Manager struct {
 	clickhouseConn clickhouse.Conn
 
-	licenseRepo *license.Repo
+	licenseService licensing.Licensing
 
 	scheduler *gocron.Scheduler
 
-	modelDao dao.ModelDao
-
 	zeus zeus.Zeus
+
+	organizationModule organization.Module
 }
 
-func New(modelDao dao.ModelDao, licenseRepo *license.Repo, clickhouseConn clickhouse.Conn, zeus zeus.Zeus) (*Manager, error) {
+func New(licenseService licensing.Licensing, clickhouseConn clickhouse.Conn, zeus zeus.Zeus, organizationModule organization.Module) (*Manager, error) {
 	m := &Manager{
-		clickhouseConn: clickhouseConn,
-		licenseRepo:    licenseRepo,
-		scheduler:      gocron.NewScheduler(time.UTC).Every(1).Day().At("00:00"), // send usage every at 00:00 UTC
-		modelDao:       modelDao,
-		zeus:           zeus,
+		clickhouseConn:     clickhouseConn,
+		licenseService:     licenseService,
+		scheduler:          gocron.NewScheduler(time.UTC).Every(1).Day().At("00:00"), // send usage every at 00:00 UTC
+		zeus:               zeus,
+		organizationModule: organizationModule,
 	}
 	return m, nil
 }
 
 // start loads collects and exports any exported snapshot and starts the exporter
-func (lm *Manager) Start() error {
+func (lm *Manager) Start(ctx context.Context) error {
 	// compares the locker and stateUnlocked if both are same lock is applied else returns error
 	if !atomic.CompareAndSwapUint32(&locker, stateUnlocked, stateLocked) {
 		return fmt.Errorf("usage exporter is locked")
 	}
 
-	_, err := lm.scheduler.Do(func() { lm.UploadUsage() })
+	// upload usage once when starting the service
+
+	_, err := lm.scheduler.Do(func() { lm.UploadUsage(ctx) })
 	if err != nil {
 		return err
 	}
 
-	// upload usage once when starting the service
-	lm.UploadUsage()
-
+	lm.UploadUsage(ctx)
 	lm.scheduler.StartAsync()
-
 	return nil
 }
-func (lm *Manager) UploadUsage() {
-	ctx := context.Background()
-	// check if license is present or not
-	license, err := lm.licenseRepo.GetActiveLicense(ctx)
+func (lm *Manager) UploadUsage(ctx context.Context) {
+
+	organizations, err := lm.organizationModule.GetAll(context.Background())
 	if err != nil {
-		zap.L().Error("failed to get active license", zap.Error(err))
-		return
-	}
-	if license == nil {
-		// we will not start the usage reporting if license is not present.
-		zap.L().Info("no license present, skipping usage reporting")
+		zap.L().Error("failed to get organizations", zap.Error(err))
 		return
 	}
+	for _, organization := range organizations {
+		// check if license is present or not
+		license, err := lm.licenseService.GetActive(ctx, organization.ID)
+		if err != nil {
+			zap.L().Error("failed to get active license", zap.Error(err))
+			return
+		}
+		if license == nil {
+			// we will not start the usage reporting if license is not present.
+			zap.L().Info("no license present, skipping usage reporting")
+			return
+		}
 
-	usages := []model.UsageDB{}
+		usages := []model.UsageDB{}
 
-	// get usage from clickhouse
-	dbs := []string{"signoz_logs", "signoz_traces", "signoz_metrics"}
-	query := `
+		// get usage from clickhouse
+		dbs := []string{"signoz_logs", "signoz_traces", "signoz_metrics"}
+		query := `
 		SELECT tenant, collector_id, exporter_id, timestamp, data
 		FROM %s.distributed_usage as u1 
 			GLOBAL INNER JOIN 
@@ -107,76 +112,76 @@ func (lm *Manager) UploadUsage() {
 		order by timestamp
 	`
 
-	for _, db := range dbs {
-		dbusages := []model.UsageDB{}
-		err := lm.clickhouseConn.Select(ctx, &dbusages, fmt.Sprintf(query, db, db), time.Now().Add(-(24 * time.Hour)))
-		if err != nil && !strings.Contains(err.Error(), "doesn't exist") {
-			zap.L().Error("failed to get usage from clickhouse: %v", zap.Error(err))
-			return
+		for _, db := range dbs {
+			dbusages := []model.UsageDB{}
+			err := lm.clickhouseConn.Select(ctx, &dbusages, fmt.Sprintf(query, db, db), time.Now().Add(-(24 * time.Hour)))
+			if err != nil && !strings.Contains(err.Error(), "doesn't exist") {
+				zap.L().Error("failed to get usage from clickhouse: %v", zap.Error(err))
+				return
+			}
+			for _, u := range dbusages {
+				u.Type = db
+				usages = append(usages, u)
+			}
 		}
-		for _, u := range dbusages {
-			u.Type = db
-			usages = append(usages, u)
-		}
-	}
 
-	if len(usages) <= 0 {
-		zap.L().Info("no snapshots to upload, skipping.")
-		return
-	}
-
-	zap.L().Info("uploading usage data")
-
-	usagesPayload := []model.Usage{}
-	for _, usage := range usages {
-		usageDataBytes, err := encryption.Decrypt([]byte(usage.ExporterID[:32]), []byte(usage.Data))
-		if err != nil {
-			zap.L().Error("error while decrypting usage data: %v", zap.Error(err))
+		if len(usages) <= 0 {
+			zap.L().Info("no snapshots to upload, skipping.")
 			return
 		}
 
-		usageData := model.Usage{}
-		err = json.Unmarshal(usageDataBytes, &usageData)
-		if err != nil {
-			zap.L().Error("error while unmarshalling usage data: %v", zap.Error(err))
+		zap.L().Info("uploading usage data")
+
+		usagesPayload := []model.Usage{}
+		for _, usage := range usages {
+			usageDataBytes, err := encryption.Decrypt([]byte(usage.ExporterID[:32]), []byte(usage.Data))
+			if err != nil {
+				zap.L().Error("error while decrypting usage data: %v", zap.Error(err))
+				return
+			}
+
+			usageData := model.Usage{}
+			err = json.Unmarshal(usageDataBytes, &usageData)
+			if err != nil {
+				zap.L().Error("error while unmarshalling usage data: %v", zap.Error(err))
+				return
+			}
+
+			usageData.CollectorID = usage.CollectorID
+			usageData.ExporterID = usage.ExporterID
+			usageData.Type = usage.Type
+			usageData.Tenant = "default"
+			usageData.OrgName = "default"
+			usageData.TenantId = "default"
+			usagesPayload = append(usagesPayload, usageData)
+		}
+
+		key, _ := uuid.Parse(license.Key)
+		payload := model.UsagePayload{
+			LicenseKey: key,
+			Usage:      usagesPayload,
+		}
+
+		body, errv2 := json.Marshal(payload)
+		if errv2 != nil {
+			zap.L().Error("error while marshalling usage payload: %v", zap.Error(errv2))
 			return
 		}
 
-		usageData.CollectorID = usage.CollectorID
-		usageData.ExporterID = usage.ExporterID
-		usageData.Type = usage.Type
-		usageData.Tenant = "default"
-		usageData.OrgName = "default"
-		usageData.TenantId = "default"
-		usagesPayload = append(usagesPayload, usageData)
-	}
-
-	key, _ := uuid.Parse(license.Key)
-	payload := model.UsagePayload{
-		LicenseKey: key,
-		Usage:      usagesPayload,
-	}
-
-	body, errv2 := json.Marshal(payload)
-	if errv2 != nil {
-		zap.L().Error("error while marshalling usage payload: %v", zap.Error(errv2))
-		return
-	}
-
-	errv2 = lm.zeus.PutMeters(ctx, payload.LicenseKey.String(), body)
-	if errv2 != nil {
-		zap.L().Error("failed to upload usage: %v", zap.Error(errv2))
-		// not returning error here since it is captured in the failed count
-		return
+		errv2 = lm.zeus.PutMeters(ctx, payload.LicenseKey.String(), body)
+		if errv2 != nil {
+			zap.L().Error("failed to upload usage: %v", zap.Error(errv2))
+			// not returning error here since it is captured in the failed count
+			return
+		}
 	}
 }
 
-func (lm *Manager) Stop() {
+func (lm *Manager) Stop(ctx context.Context) {
 	lm.scheduler.Stop()
 
 	zap.L().Info("sending usage data before shutting down")
 	// send usage before shutting down
-	lm.UploadUsage()
-
+	lm.UploadUsage(ctx)
 	atomic.StoreUint32(&locker, stateUnlocked)
 }

ee/sqlstore/postgressqlstore/dialect.go

@@ -19,6 +19,7 @@ var (
 var (
 	Org              = "org"
 	User             = "user"
+	UserNoCascade    = "user_no_cascade"
 	FactorPassword   = "factor_password"
 	CloudIntegration = "cloud_integration"
 )
@@ -26,6 +27,7 @@ var (
 var (
 	OrgReference              = `("org_id") REFERENCES "organizations" ("id")`
 	UserReference             = `("user_id") REFERENCES "users" ("id") ON DELETE CASCADE ON UPDATE CASCADE`
+	UserReferenceNoCascade    = `("user_id") REFERENCES "users" ("id")`
 	FactorPasswordReference   = `("password_id") REFERENCES "factor_password" ("id")`
 	CloudIntegrationReference = `("cloud_integration_id") REFERENCES "cloud_integration" ("id") ON DELETE CASCADE`
 )
@@ -266,6 +268,8 @@ func (dialect *dialect) RenameTableAndModifyModel(ctx context.Context, bun bun.I
 			fkReferences = append(fkReferences, OrgReference)
 		} else if reference == User && !slices.Contains(fkReferences, UserReference) {
 			fkReferences = append(fkReferences, UserReference)
+		} else if reference == UserNoCascade && !slices.Contains(fkReferences, UserReferenceNoCascade) {
+			fkReferences = append(fkReferences, UserReferenceNoCascade)
 		} else if reference == FactorPassword && !slices.Contains(fkReferences, FactorPasswordReference) {
 			fkReferences = append(fkReferences, FactorPasswordReference)
 		} else if reference == CloudIntegration && !slices.Contains(fkReferences, CloudIntegrationReference) {

ee/types/personal_access_token.go

@@ -1,76 +0,0 @@
-package types
-
-import (
-	"crypto/rand"
-	"encoding/base64"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/uptrace/bun"
-)
-
-type GettablePAT struct {
-	CreatedByUser PatUser `json:"createdByUser"`
-	UpdatedByUser PatUser `json:"updatedByUser"`
-
-	StorablePersonalAccessToken
-}
-
-type PatUser struct {
-	types.User
-	NotFound bool `json:"notFound"`
-}
-
-func NewGettablePAT(name, role, userID string, expiresAt int64) GettablePAT {
-	return GettablePAT{
-		StorablePersonalAccessToken: NewStorablePersonalAccessToken(name, role, userID, expiresAt),
-	}
-}
-
-type StorablePersonalAccessToken struct {
-	bun.BaseModel `bun:"table:personal_access_token"`
-	types.Identifiable
-	types.TimeAuditable
-	OrgID           string `json:"orgId" bun:"org_id,type:text,notnull"`
-	Role            string `json:"role" bun:"role,type:text,notnull,default:'ADMIN'"`
-	UserID          string `json:"userId" bun:"user_id,type:text,notnull"`
-	Token           string `json:"token" bun:"token,type:text,notnull,unique"`
-	Name            string `json:"name" bun:"name,type:text,notnull"`
-	ExpiresAt       int64  `json:"expiresAt" bun:"expires_at,notnull,default:0"`
-	LastUsed        int64  `json:"lastUsed" bun:"last_used,notnull,default:0"`
-	Revoked         bool   `json:"revoked" bun:"revoked,notnull,default:false"`
-	UpdatedByUserID string `json:"updatedByUserId" bun:"updated_by_user_id,type:text,notnull,default:''"`
-}
-
-func NewStorablePersonalAccessToken(name, role, userID string, expiresAt int64) StorablePersonalAccessToken {
-	now := time.Now()
-	if expiresAt != 0 {
-		// convert expiresAt to unix timestamp from days
-		expiresAt = now.Unix() + (expiresAt * 24 * 60 * 60)
-	}
-
-	// Generate a 32-byte random token.
-	token := make([]byte, 32)
-	rand.Read(token)
-	// Encode the token in base64.
-	encodedToken := base64.StdEncoding.EncodeToString(token)
-
-	return StorablePersonalAccessToken{
-		Token:           encodedToken,
-		Name:            name,
-		Role:            role,
-		UserID:          userID,
-		ExpiresAt:       expiresAt,
-		LastUsed:        0,
-		Revoked:         false,
-		UpdatedByUserID: "",
-		TimeAuditable: types.TimeAuditable{
-			CreatedAt: now,
-			UpdatedAt: now,
-		},
-		Identifiable: types.Identifiable{
-			ID: valuer.GenerateUUID(),
-		},
-	}
-}

frontend/example.env

@@ -1,6 +1,7 @@
 NODE_ENV="development"
 BUNDLE_ANALYSER="true"
 FRONTEND_API_ENDPOINT="http://localhost:8080/"
-INTERCOM_APP_ID="intercom-app-id"
+PYLON_APP_ID="pylon-app-id"
+APPCUES_APP_ID="appcess-app-id"
 
 CI="1"

frontend/jest.config.ts

@@ -15,6 +15,7 @@ const config: Config.InitialOptions = {
 		extensionsToTreatAsEsm: ['.ts'],
 		'ts-jest': {
 			useESM: true,
+			isolatedModules: true,
 		},
 	},
 	testMatch: ['<rootDir>/src/**/*?(*.)(test).(ts|js)?(x)'],

frontend/package.json

@@ -31,6 +31,7 @@
 		"@dnd-kit/core": "6.1.0",
 		"@dnd-kit/modifiers": "7.0.0",
 		"@dnd-kit/sortable": "8.0.0",
+		"@dnd-kit/utilities": "3.2.2",
 		"@grafana/data": "^11.2.3",
 		"@mdx-js/loader": "2.3.0",
 		"@mdx-js/react": "2.3.0",

frontend/public/locales/en-GB/services.json

@@ -1,3 +1,3 @@
 {
-	"rps_over_100": "You are sending data at more than 100 RPS, your ingestion  may be rate limited. Please reach out to us via Intercom support or "
+	"rps_over_100": "You are sending data at more than 100 RPS, your ingestion  may be rate limited. Please reach out to us via chat support or "
 }

frontend/public/locales/en/services.json

@@ -1,3 +1,3 @@
 {
-	"rps_over_100": "You are sending data at more than 100 RPS, your ingestion  may be rate limited. Please reach out to us via Intercom support or "
+	"rps_over_100": "You are sending data at more than 100 RPS, your ingestion  may be rate limited. Please reach out to us via chat support or "
 }

frontend/public/locales/en/titles.json

@@ -69,5 +69,5 @@
 	"METRICS_EXPLORER": "SigNoz | Metrics Explorer",
 	"METRICS_EXPLORER_EXPLORER": "SigNoz | Metrics Explorer",
 	"METRICS_EXPLORER_VIEWS": "SigNoz | Metrics Explorer",
-	"API_MONITORING": "SigNoz | Third Party API"
+	"API_MONITORING": "SigNoz | External APIs"
 }

frontend/src/AppRoutes/Private.tsx

@@ -36,8 +36,8 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 		user,
 		isLoggedIn: isLoggedInState,
 		isFetchingOrgPreferences,
-		activeLicenseV3,
-		isFetchingActiveLicenseV3,
+		activeLicense,
+		isFetchingActiveLicense,
 		trialInfo,
 		featureFlags,
 	} = useAppContext();
@@ -145,16 +145,16 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 	};
 
 	useEffect(() => {
-		if (!isFetchingActiveLicenseV3 && activeLicenseV3) {
+		if (!isFetchingActiveLicense && activeLicense) {
 			const currentRoute = mapRoutes.get('current');
 
-			const isTerminated = activeLicenseV3.state === LicenseState.TERMINATED;
-			const isExpired = activeLicenseV3.state === LicenseState.EXPIRED;
-			const isCancelled = activeLicenseV3.state === LicenseState.CANCELLED;
+			const isTerminated = activeLicense.state === LicenseState.TERMINATED;
+			const isExpired = activeLicense.state === LicenseState.EXPIRED;
+			const isCancelled = activeLicense.state === LicenseState.CANCELLED;
 
 			const isWorkspaceAccessRestricted = isTerminated || isExpired || isCancelled;
 
-			const { platform } = activeLicenseV3;
+			const { platform } = activeLicense;
 
 			if (
 				isWorkspaceAccessRestricted &&
@@ -164,26 +164,26 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 				navigateToWorkSpaceAccessRestricted(currentRoute);
 			}
 		}
-	}, [isFetchingActiveLicenseV3, activeLicenseV3, mapRoutes, pathname]);
+	}, [isFetchingActiveLicense, activeLicense, mapRoutes, pathname]);
 
 	useEffect(() => {
-		if (!isFetchingActiveLicenseV3) {
+		if (!isFetchingActiveLicense) {
 			const currentRoute = mapRoutes.get('current');
 			const shouldBlockWorkspace = trialInfo?.workSpaceBlock;
 
 			if (
 				shouldBlockWorkspace &&
 				currentRoute &&
-				activeLicenseV3?.platform === LicensePlatform.CLOUD
+				activeLicense?.platform === LicensePlatform.CLOUD
 			) {
 				navigateToWorkSpaceBlocked(currentRoute);
 			}
 		}
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [
-		isFetchingActiveLicenseV3,
+		isFetchingActiveLicense,
 		trialInfo?.workSpaceBlock,
-		activeLicenseV3?.platform,
+		activeLicense?.platform,
 		mapRoutes,
 		pathname,
 	]);
@@ -197,20 +197,20 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 	};
 
 	useEffect(() => {
-		if (!isFetchingActiveLicenseV3 && activeLicenseV3) {
+		if (!isFetchingActiveLicense && activeLicense) {
 			const currentRoute = mapRoutes.get('current');
 			const shouldSuspendWorkspace =
-				activeLicenseV3.state === LicenseState.DEFAULTED;
+				activeLicense.state === LicenseState.DEFAULTED;
 
 			if (
 				shouldSuspendWorkspace &&
 				currentRoute &&
-				activeLicenseV3.platform === LicensePlatform.CLOUD
+				activeLicense.platform === LicensePlatform.CLOUD
 			) {
 				navigateToWorkSpaceSuspended(currentRoute);
 			}
 		}
-	}, [isFetchingActiveLicenseV3, activeLicenseV3, mapRoutes, pathname]);
+	}, [isFetchingActiveLicense, activeLicense, mapRoutes, pathname]);
 
 	useEffect(() => {
 		if (org && org.length > 0 && org[0].id !== undefined) {

frontend/src/AppRoutes/index.tsx

@@ -13,9 +13,9 @@ import AppLayout from 'container/AppLayout';
 import { KeyboardHotkeysProvider } from 'hooks/hotkeys/useKeyboardHotkeys';
 import { useThemeConfig } from 'hooks/useDarkMode';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
-import { LICENSE_PLAN_KEY } from 'hooks/useLicense';
 import { NotificationProvider } from 'hooks/useNotifications';
 import { ResourceProvider } from 'hooks/useResourceAttribute';
+import { StatusCodes } from 'http-status-codes';
 import history from 'lib/history';
 import ErrorBoundaryFallback from 'pages/ErrorBoundaryFallback/ErrorBoundaryFallback';
 import posthog from 'posthog-js';
@@ -23,6 +23,7 @@ import AlertRuleProvider from 'providers/Alert';
 import { useAppContext } from 'providers/App/App';
 import { IUser } from 'providers/App/types';
 import { DashboardProvider } from 'providers/Dashboard/Dashboard';
+import { ErrorModalProvider } from 'providers/ErrorModalProvider';
 import { QueryBuilderProvider } from 'providers/QueryBuilder';
 import { Suspense, useCallback, useEffect, useState } from 'react';
 import { Route, Router, Switch } from 'react-router-dom';
@@ -41,14 +42,13 @@ import defaultRoutes, {
 function App(): JSX.Element {
 	const themeConfig = useThemeConfig();
 	const {
-		licenses,
 		user,
 		isFetchingUser,
-		isFetchingLicenses,
 		isFetchingFeatureFlags,
 		trialInfo,
-		activeLicenseV3,
-		isFetchingActiveLicenseV3,
+		activeLicense,
+		isFetchingActiveLicense,
+		activeLicenseFetchError,
 		userFetchError,
 		featureFlagsFetchError,
 		isLoggedIn: isLoggedInState,
@@ -66,7 +66,7 @@ function App(): JSX.Element {
 	const enableAnalytics = useCallback(
 		(user: IUser): void => {
 			// wait for the required data to be loaded before doing init for anything!
-			if (!isFetchingActiveLicenseV3 && activeLicenseV3 && org) {
+			if (!isFetchingActiveLicense && activeLicense && org) {
 				const orgName =
 					org && Array.isArray(org) && org.length > 0 ? org[0].displayName : '';
 
@@ -103,6 +103,20 @@ function App(): JSX.Element {
 				if (domain) {
 					logEvent('Domain Identified', groupTraits, 'group');
 				}
+				if (window && window.Appcues) {
+					window.Appcues.identify(email, {
+						name: displayName,
+
+						tenant_id: hostNameParts[0],
+						data_region: hostNameParts[1],
+						tenant_url: hostname,
+						company_domain: domain,
+
+						companyName: orgName,
+						email,
+						paidUser: !!trialInfo?.trialConvertedToSubscription,
+					});
+				}
 
 				Userpilot.identify(email, {
 					email,
@@ -137,24 +151,12 @@ function App(): JSX.Element {
 					source: 'signoz-ui',
 					isPaidUser: !!trialInfo?.trialConvertedToSubscription,
 				});
-
-				if (
-					window.cioanalytics &&
-					typeof window.cioanalytics.identify === 'function'
-				) {
-					window.cioanalytics.reset();
-					window.cioanalytics.identify(email, {
-						name: user.displayName,
-						email,
-						role: user.role,
-					});
-				}
 			}
 		},
 		[
 			hostname,
-			isFetchingActiveLicenseV3,
-			activeLicenseV3,
+			isFetchingActiveLicense,
+			activeLicense,
 			org,
 			trialInfo?.trialConvertedToSubscription,
 		],
@@ -163,18 +165,17 @@ function App(): JSX.Element {
 	// eslint-disable-next-line sonarjs/cognitive-complexity
 	useEffect(() => {
 		if (
-			!isFetchingLicenses &&
-			licenses &&
+			!isFetchingActiveLicense &&
+			(activeLicense || activeLicenseFetchError) &&
 			!isFetchingUser &&
 			user &&
 			!!user.email
 		) {
 			const isOnBasicPlan =
-				licenses.licenses?.some(
-					(license) =>
-						license.isCurrent && license.planKey === LICENSE_PLAN_KEY.BASIC_PLAN,
-				) || licenses.licenses === null;
-
+				activeLicenseFetchError &&
+				[StatusCodes.NOT_FOUND, StatusCodes.NOT_IMPLEMENTED].includes(
+					activeLicenseFetchError?.getHttpStatusCode(),
+				);
 			const isIdentifiedUser = getLocalStorageApi(LOCALSTORAGE.IS_IDENTIFIED_USER);
 
 			if (isLoggedInState && user && user.id && user.email && !isIdentifiedUser) {
@@ -204,22 +205,23 @@ function App(): JSX.Element {
 	}, [
 		isLoggedInState,
 		user,
-		licenses,
 		isCloudUser,
 		isEnterpriseSelfHostedUser,
-		isFetchingLicenses,
+		isFetchingActiveLicense,
 		isFetchingUser,
+		activeLicense,
+		activeLicenseFetchError,
 	]);
 
 	useEffect(() => {
 		if (pathname === ROUTES.ONBOARDING) {
-			window.Intercom('update', {
-				hide_default_launcher: true,
-			});
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			// @ts-ignore
+			window.Pylon('hideChatBubble');
 		} else {
-			window.Intercom('update', {
-				hide_default_launcher: false,
-			});
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			// @ts-ignore
+			window.Pylon('showChatBubble');
 		}
 	}, [pathname]);
 
@@ -231,8 +233,7 @@ function App(): JSX.Element {
 		if (
 			!isFetchingFeatureFlags &&
 			(featureFlags || featureFlagsFetchError) &&
-			licenses &&
-			activeLicenseV3 &&
+			activeLicense &&
 			trialInfo
 		) {
 			let isChatSupportEnabled = false;
@@ -255,11 +256,13 @@ function App(): JSX.Element {
 				!showAddCreditCardModal &&
 				(isCloudUser || isEnterpriseSelfHostedUser)
 			) {
-				window.Intercom('boot', {
-					app_id: process.env.INTERCOM_APP_ID,
-					email: user?.email || '',
-					name: user?.displayName || '',
-				});
+				window.pylon = {
+					chat_settings: {
+						app_id: process.env.PYLON_APP_ID,
+						email: user.email,
+						name: user.displayName,
+					},
+				};
 			}
 		}
 	}, [
@@ -270,8 +273,7 @@ function App(): JSX.Element {
 		featureFlags,
 		isFetchingFeatureFlags,
 		featureFlagsFetchError,
-		licenses,
-		activeLicenseV3,
+		activeLicense,
 		trialInfo,
 		isCloudUser,
 		isEnterpriseSelfHostedUser,
@@ -322,10 +324,6 @@ function App(): JSX.Element {
 		} else {
 			posthog.reset();
 			Sentry.close();
-
-			if (window.cioanalytics && typeof window.cioanalytics.reset === 'function') {
-				window.cioanalytics.reset();
-			}
 		}
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [isCloudUser, isEnterpriseSelfHostedUser]);
@@ -333,7 +331,7 @@ function App(): JSX.Element {
 	// if the user is in logged in state
 	if (isLoggedInState) {
 		// if the setup calls are loading then return a spinner
-		if (isFetchingLicenses || isFetchingUser || isFetchingFeatureFlags) {
+		if (isFetchingActiveLicense || isFetchingUser || isFetchingFeatureFlags) {
 			return <Spinner tip="Loading..." />;
 		}
 
@@ -345,7 +343,11 @@ function App(): JSX.Element {
 		}
 
 		// if all of the data is not set then return a spinner, this is required because there is some gap between loading states and data setting
-		if ((!licenses || !user.email || !featureFlags) && !userFetchError) {
+		if (
+			(!activeLicense || !user.email || !featureFlags) &&
+			!userFetchError &&
+			!activeLicenseFetchError
+		) {
 			return <Spinner tip="Loading..." />;
 		}
 	}
@@ -357,34 +359,36 @@ function App(): JSX.Element {
 					<CompatRouter>
 						<UserpilotRouteTracker />
 						<NotificationProvider>
-							<PrivateRoute>
-								<ResourceProvider>
-									<QueryBuilderProvider>
-										<DashboardProvider>
-											<KeyboardHotkeysProvider>
-												<AlertRuleProvider>
-													<AppLayout>
-														<Suspense fallback={<Spinner size="large" tip="Loading..." />}>
-															<Switch>
-																{routes.map(({ path, component, exact }) => (
-																	<Route
-																		key={`${path}`}
-																		exact={exact}
-																		path={path}
-																		component={component}
-																	/>
-																))}
-																<Route exact path="/" component={Home} />
-																<Route path="*" component={NotFound} />
-															</Switch>
-														</Suspense>
-													</AppLayout>
-												</AlertRuleProvider>
-											</KeyboardHotkeysProvider>
-										</DashboardProvider>
-									</QueryBuilderProvider>
-								</ResourceProvider>
-							</PrivateRoute>
+							<ErrorModalProvider>
+								<PrivateRoute>
+									<ResourceProvider>
+										<QueryBuilderProvider>
+											<DashboardProvider>
+												<KeyboardHotkeysProvider>
+													<AlertRuleProvider>
+														<AppLayout>
+															<Suspense fallback={<Spinner size="large" tip="Loading..." />}>
+																<Switch>
+																	{routes.map(({ path, component, exact }) => (
+																		<Route
+																			key={`${path}`}
+																			exact={exact}
+																			path={path}
+																			component={component}
+																		/>
+																	))}
+																	<Route exact path="/" component={Home} />
+																	<Route path="*" component={NotFound} />
+																</Switch>
+															</Suspense>
+														</AppLayout>
+													</AlertRuleProvider>
+												</KeyboardHotkeysProvider>
+											</DashboardProvider>
+										</QueryBuilderProvider>
+									</ResourceProvider>
+								</PrivateRoute>
+							</ErrorModalProvider>
 						</NotificationProvider>
 					</CompatRouter>
 				</Router>

frontend/src/api/APIKeys/createAPIKey.ts

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

frontend/src/api/APIKeys/deleteAPIKey.ts

@@ -1,24 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
-import { AxiosError } from 'axios';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { AllAPIKeyProps } from 'types/api/pat/types';
-
-const deleteAPIKey = async (
-	id: string,
-): Promise<SuccessResponse<AllAPIKeyProps> | ErrorResponse> => {
-	try {
-		const response = await axios.delete(`/pats/${id}`);
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: response.data.status,
-			payload: response.data.data,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};
-
-export default deleteAPIKey;

frontend/src/api/APIKeys/getAPIKey.ts

@@ -1,24 +0,0 @@
-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/get';
-
-const get = async (
-	props: Props,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	try {
-		const response = await axios.get(`/pats/${props.id}`);
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: response.data.status,
-			payload: response.data,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};
-
-export default get;

frontend/src/api/APIKeys/getAllAPIKeys.ts

@@ -1,6 +0,0 @@
-import axios from 'api';
-import { AxiosResponse } from 'axios';
-import { AllAPIKeyProps } from 'types/api/pat/types';
-
-export const getAllAPIKeys = (): Promise<AxiosResponse<AllAPIKeyProps>> =>
-	axios.get(`/pats`);

frontend/src/api/APIKeys/updateAPIKey.ts

@@ -1,26 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
-import { AxiosError } from 'axios';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PayloadProps, UpdateAPIKeyProps } from 'types/api/pat/types';
-
-const updateAPIKey = async (
-	props: UpdateAPIKeyProps,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	try {
-		const response = await axios.put(`/pats/${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 updateAPIKey;

frontend/src/api/SAML/deleteDomain.ts

@@ -1,24 +0,0 @@
-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/SAML/deleteDomain';
-
-const deleteDomain = async (
-	props: Props,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	try {
-		const response = await axios.delete(`/domains/${props.id}`);
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: response.data.status,
-			payload: response.data.data,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};
-
-export default deleteDomain;

frontend/src/api/SAML/listAllDomain.ts

@@ -1,24 +0,0 @@
-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/SAML/listDomain';
-
-const listAllDomain = async (
-	props: Props,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	try {
-		const response = await axios.get(`/orgs/${props.orgId}/domains`);
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: response.data.status,
-			payload: response.data.data,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};
-
-export default listAllDomain;

frontend/src/api/SAML/updateDomain.ts

@@ -1,24 +0,0 @@
-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/SAML/updateDomain';
-
-const updateDomain = async (
-	props: Props,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	try {
-		const response = await axios.put(`/domains/${props.id}`, props);
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: response.data.status,
-			payload: response.data.data,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};
-
-export default updateDomain;

frontend/src/api/billing/checkout.ts

@@ -1,29 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
-import { AxiosError } from 'axios';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import {
-	CheckoutRequestPayloadProps,
-	CheckoutSuccessPayloadProps,
-} from 'types/api/billing/checkout';
-
-const updateCreditCardApi = async (
-	props: CheckoutRequestPayloadProps,
-): Promise<SuccessResponse<CheckoutSuccessPayloadProps> | ErrorResponse> => {
-	try {
-		const response = await axios.post('/checkout', {
-			url: props.url,
-		});
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: response.data.status,
-			payload: response.data.data,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};
-
-export default updateCreditCardApi;

frontend/src/api/billing/manage.ts

@@ -1,29 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
-import { AxiosError } from 'axios';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import {
-	CheckoutRequestPayloadProps,
-	CheckoutSuccessPayloadProps,
-} from 'types/api/billing/checkout';
-
-const manageCreditCardApi = async (
-	props: CheckoutRequestPayloadProps,
-): Promise<SuccessResponse<CheckoutSuccessPayloadProps> | ErrorResponse> => {
-	try {
-		const response = await axios.post('/portal', {
-			url: props.url,
-		});
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: response.data.status,
-			payload: response.data.data,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};
-
-export default manageCreditCardApi;

frontend/src/api/index.ts

@@ -4,7 +4,11 @@
 import getLocalStorageApi from 'api/browser/localstorage/get';
 import loginApi from 'api/v1/login/login';
 import afterLogin from 'AppRoutes/utils';
-import axios, { AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+import axios, {
+	AxiosError,
+	AxiosResponse,
+	InternalAxiosRequestConfig,
+} from 'axios';
 import { ENVIRONMENT } from 'constants/env';
 import { Events } from 'constants/events';
 import { LOCALSTORAGE } from 'constants/localStorage';
@@ -83,24 +87,27 @@ const interceptorRejected = async (
 						true,
 					);
 
-					const reResponse = await axios(
-						`${value.config.baseURL}${value.config.url?.substring(1)}`,
-						{
-							method: value.config.method,
-							headers: {
-								...value.config.headers,
-								Authorization: `Bearer ${response.data.accessJwt}`,
+					try {
+						const reResponse = await axios(
+							`${value.config.baseURL}${value.config.url?.substring(1)}`,
+							{
+								method: value.config.method,
+								headers: {
+									...value.config.headers,
+									Authorization: `Bearer ${response.data.accessJwt}`,
+								},
+								data: {
+									...JSON.parse(value.config.data || '{}'),
+								},
 							},
-							data: {
-								...JSON.parse(value.config.data || '{}'),
-							},
-						},
-					);
-					if (reResponse.status === 200) {
+						);
+
 						return await Promise.resolve(reResponse);
+					} catch (error) {
+						if ((error as AxiosError)?.response?.status === 401) {
+							Logout();
+						}
 					}
-					Logout();
-					return await Promise.reject(reResponse);
 				} catch (error) {
 					Logout();
 				}

frontend/src/api/licenses/apply.ts

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

frontend/src/api/licenses/getAll.ts

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

frontend/src/api/licensesV3/getActive.ts

@@ -1,18 +0,0 @@
-import { ApiV3Instance as axios } from 'api';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { LicenseV3EventQueueResModel } from 'types/api/licensesV3/getActive';
-
-const getActive = async (): Promise<
-	SuccessResponse<LicenseV3EventQueueResModel> | ErrorResponse
-> => {
-	const response = await axios.get('/licenses/active');
-
-	return {
-		statusCode: 200,
-		error: null,
-		message: response.data.status,
-		payload: response.data.data,
-	};
-};
-
-export default getActive;

frontend/src/api/metrics/ApDex/getApDexSettings.ts

@@ -1,8 +0,0 @@
-import axios from 'api';
-import { AxiosResponse } from 'axios';
-import { ApDexPayloadAndSettingsProps } from 'types/api/metrics/getApDex';
-
-export const getApDexSettings = (
-	servicename: string,
-): Promise<AxiosResponse<ApDexPayloadAndSettingsProps[]>> =>
-	axios.get(`/settings/apdex?services=${servicename}`);

frontend/src/api/quickFilters/getCustomFilters.ts

@@ -1,19 +1,20 @@
-import axios from 'api';
+import { ApiBaseInstance } from 'api';
 import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
 import { AxiosError } from 'axios';
 import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PayloadProps, Props } from 'types/api/SAML/postDomain';
+import { PayloadProps, Props } from 'types/api/quickFilters/getCustomFilters';
 
-const postDomain = async (
+const getCustomFilters = async (
 	props: Props,
 ): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
+	const { signal } = props;
 	try {
-		const response = await axios.post(`/domains`, props);
+		const response = await ApiBaseInstance.get(`orgs/me/filters/${signal}`);
 
 		return {
 			statusCode: 200,
 			error: null,
-			message: response.data.status,
+			message: 'Success',
 			payload: response.data.data,
 		};
 	} catch (error) {
@@ -21,4 +22,4 @@ const postDomain = async (
 	}
 };
 
-export default postDomain;
+export default getCustomFilters;

frontend/src/api/quickFilters/updateCustomFilters.ts

@@ -0,0 +1,13 @@
+import { ApiBaseInstance } from 'api';
+import { AxiosError } from 'axios';
+import { SuccessResponse } from 'types/api';
+import { UpdateCustomFiltersProps } from 'types/api/quickFilters/updateCustomFilters';
+
+const updateCustomFiltersAPI = async (
+	props: UpdateCustomFiltersProps,
+): Promise<SuccessResponse<void> | AxiosError> =>
+	ApiBaseInstance.put(`orgs/me/filters`, {
+		...props.data,
+	});
+
+export default updateCustomFiltersAPI;

frontend/src/api/traceFunnels/index.ts

@@ -22,7 +22,7 @@ export const createFunnel = async (
 		statusCode: 200,
 		error: null,
 		message: 'Funnel created successfully',
-		payload: response.data,
+		payload: response.data.data,
 	};
 };
 
@@ -196,7 +196,9 @@ export interface FunnelOverviewResponse {
 			avg_rate: number;
 			conversion_rate: number | null;
 			errors: number;
+			// TODO(shaheer): remove p99_latency once we have support for latency
 			p99_latency: number;
+			latency: number;
 		};
 	}>;
 }
@@ -222,13 +224,6 @@ export const getFunnelOverview = async (
 	};
 };
 
-export interface SlowTracesPayload {
-	start_time: number;
-	end_time: number;
-	step_a_order: number;
-	step_b_order: number;
-}
-
 export interface SlowTraceData {
 	status: string;
 	data: Array<{
@@ -243,7 +238,7 @@ export interface SlowTraceData {
 
 export const getFunnelSlowTraces = async (
 	funnelId: string,
-	payload: SlowTracesPayload,
+	payload: FunnelOverviewPayload,
 	signal?: AbortSignal,
 ): Promise<SuccessResponse<SlowTraceData> | ErrorResponse> => {
 	const response = await axios.post(
@@ -261,12 +256,6 @@ export const getFunnelSlowTraces = async (
 		payload: response.data,
 	};
 };
-export interface ErrorTracesPayload {
-	start_time: number;
-	end_time: number;
-	step_a_order: number;
-	step_b_order: number;
-}
 
 export interface ErrorTraceData {
 	status: string;
@@ -282,7 +271,7 @@ export interface ErrorTraceData {
 
 export const getFunnelErrorTraces = async (
 	funnelId: string,
-	payload: ErrorTracesPayload,
+	payload: FunnelOverviewPayload,
 	signal?: AbortSignal,
 ): Promise<SuccessResponse<ErrorTraceData> | ErrorResponse> => {
 	const response: AxiosResponse = await axios.post(
@@ -337,3 +326,37 @@ export const getFunnelSteps = async (
 		payload: response.data,
 	};
 };
+
+export interface FunnelStepsOverviewPayload {
+	start_time: number;
+	end_time: number;
+	step_start?: number;
+	step_end?: number;
+}
+
+export interface FunnelStepsOverviewResponse {
+	status: string;
+	data: Array<{
+		timestamp: string;
+		data: Record<string, number>;
+	}>;
+}
+
+export const getFunnelStepsOverview = async (
+	funnelId: string,
+	payload: FunnelStepsOverviewPayload,
+	signal?: AbortSignal,
+): Promise<SuccessResponse<FunnelStepsOverviewResponse> | ErrorResponse> => {
+	const response = await axios.post(
+		`${FUNNELS_BASE_PATH}/${funnelId}/analytics/steps/overview`,
+		payload,
+		{ signal },
+	);
+
+	return {
+		statusCode: 200,
+		error: null,
+		message: '',
+		payload: response.data,
+	};
+};

frontend/src/api/utils.ts

@@ -12,16 +12,8 @@ export const Logout = (): void => {
 	deleteLocalStorageKey(LOCALSTORAGE.LOGGED_IN_USER_NAME);
 	deleteLocalStorageKey(LOCALSTORAGE.CHAT_SUPPORT);
 	deleteLocalStorageKey(LOCALSTORAGE.USER_ID);
-
+	deleteLocalStorageKey(LOCALSTORAGE.QUICK_FILTERS_SETTINGS_ANNOUNCEMENT);
 	window.dispatchEvent(new CustomEvent('LOGOUT'));
 
-	// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-	// @ts-ignore
-	if (window && window.Intercom) {
-		// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-		// @ts-ignore
-		window.Intercom('shutdown');
-	}
-
 	history.push(ROUTES.LOGIN);
 };

frontend/src/api/v1/checkout/create.ts

@@ -0,0 +1,28 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import {
+	CheckoutRequestPayloadProps,
+	CheckoutSuccessPayloadProps,
+	PayloadProps,
+} from 'types/api/billing/checkout';
+
+const updateCreditCardApi = async (
+	props: CheckoutRequestPayloadProps,
+): Promise<SuccessResponseV2<CheckoutSuccessPayloadProps>> => {
+	try {
+		const response = await axios.post<PayloadProps>('/checkout', {
+			url: props.url,
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default updateCreditCardApi;

frontend/src/api/v1/domains/create.ts

@@ -0,0 +1,21 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { AuthDomain } from 'types/api/SAML/listDomain';
+import { PayloadProps, Props } from 'types/api/SAML/postDomain';
+
+const create = async (props: Props): Promise<SuccessResponseV2<AuthDomain>> => {
+	try {
+		const response = await axios.post<PayloadProps>(`/domains`, props);
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default create;

frontend/src/api/v1/domains/delete.ts

@@ -0,0 +1,20 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { PayloadProps, Props } from 'types/api/SAML/deleteDomain';
+
+const deleteDomain = async (props: Props): Promise<SuccessResponseV2<null>> => {
+	try {
+		const response = await axios.delete<PayloadProps>(`/domains/${props.id}`);
+
+		return {
+			httpStatusCode: response.status,
+			data: null,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default deleteDomain;

frontend/src/api/v1/domains/list.ts

@@ -0,0 +1,20 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { AuthDomain, PayloadProps } from 'types/api/SAML/listDomain';
+
+const listAllDomain = async (): Promise<SuccessResponseV2<AuthDomain[]>> => {
+	try {
+		const response = await axios.get<PayloadProps>(`/domains`);
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default listAllDomain;

frontend/src/api/v1/domains/update.ts

@@ -0,0 +1,23 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { AuthDomain } from 'types/api/SAML/listDomain';
+import { PayloadProps, Props } from 'types/api/SAML/updateDomain';
+
+const updateDomain = async (
+	props: Props,
+): Promise<SuccessResponseV2<AuthDomain>> => {
+	try {
+		const response = await axios.put<PayloadProps>(`/domains/${props.id}`, props);
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default updateDomain;

frontend/src/api/v1/pats/create.ts

@@ -0,0 +1,28 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import {
+	APIKeyProps,
+	CreateAPIKeyProps,
+	CreatePayloadProps,
+} from 'types/api/pat/types';
+
+const create = async (
+	props: CreateAPIKeyProps,
+): Promise<SuccessResponseV2<APIKeyProps>> => {
+	try {
+		const response = await axios.post<CreatePayloadProps>('/pats', {
+			...props,
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default create;

frontend/src/api/v1/pats/delete.ts

@@ -0,0 +1,19 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+
+const deleteAPIKey = async (id: string): Promise<SuccessResponseV2<null>> => {
+	try {
+		const response = await axios.delete(`/pats/${id}`);
+
+		return {
+			httpStatusCode: response.status,
+			data: null,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default deleteAPIKey;

frontend/src/api/v1/pats/list.ts

@@ -0,0 +1,20 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { AllAPIKeyProps, APIKeyProps } from 'types/api/pat/types';
+
+const list = async (): Promise<SuccessResponseV2<APIKeyProps[]>> => {
+	try {
+		const response = await axios.get<AllAPIKeyProps>('/pats');
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default list;

frontend/src/api/v1/pats/update.ts

@@ -0,0 +1,24 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { UpdateAPIKeyProps } from 'types/api/pat/types';
+
+const updateAPIKey = async (
+	props: UpdateAPIKeyProps,
+): Promise<SuccessResponseV2<null>> => {
+	try {
+		const response = await axios.put(`/pats/${props.id}`, {
+			...props.data,
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: null,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default updateAPIKey;

frontend/src/api/v1/portal/create.ts

@@ -0,0 +1,28 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import {
+	CheckoutRequestPayloadProps,
+	CheckoutSuccessPayloadProps,
+	PayloadProps,
+} from 'types/api/billing/checkout';
+
+const manageCreditCardApi = async (
+	props: CheckoutRequestPayloadProps,
+): Promise<SuccessResponseV2<CheckoutSuccessPayloadProps>> => {
+	try {
+		const response = await axios.post<PayloadProps>('/portal', {
+			url: props.url,
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default manageCreditCardApi;

frontend/src/api/v1/settings/apdex/services/get.ts

@@ -0,0 +1,26 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import {
+	ApDexPayloadAndSettingsProps,
+	PayloadProps,
+} from 'types/api/metrics/getApDex';
+
+const getApDexSettings = async (
+	servicename: string,
+): Promise<SuccessResponseV2<ApDexPayloadAndSettingsProps[]>> => {
+	try {
+		const response = await axios.get<PayloadProps>(
+			`/settings/apdex?services=${servicename}`,
+		);
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default getApDexSettings;

frontend/src/api/v3/licenses/active/get.ts

@@ -0,0 +1,25 @@
+import { ApiV3Instance as axios } from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import {
+	LicenseEventQueueResModel,
+	PayloadProps,
+} from 'types/api/licensesV3/getActive';
+
+const getActive = async (): Promise<
+	SuccessResponseV2<LicenseEventQueueResModel>
+> => {
+	try {
+		const response = await axios.get<PayloadProps>('/licenses/active');
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default getActive;

frontend/src/api/v3/licenses/put.ts

@@ -0,0 +1,24 @@
+import { ApiV3Instance as axios } from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { PayloadProps, Props } from 'types/api/licenses/apply';
+
+const apply = async (
+	props: Props,
+): Promise<SuccessResponseV2<PayloadProps>> => {
+	try {
+		const response = await axios.post<PayloadProps>('/licenses', {
+			key: props.key,
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default apply;

frontend/src/assets/Error.tsx

@@ -0,0 +1,191 @@
+import React from 'react';
+
+type ErrorIconProps = React.SVGProps<SVGSVGElement>;
+
+function ErrorIcon({ ...props }: ErrorIconProps): JSX.Element {
+	return (
+		<svg
+			width="14"
+			height="14"
+			viewBox="0 0 14 14"
+			fill="none"
+			xmlns="http://www.w3.org/2000/svg"
+			// eslint-disable-next-line react/jsx-props-no-spreading
+			{...props}
+		>
+			<path
+				fill="#C62828"
+				d="M1.281 5.78a.922.922 0 0 0-.92.921v4.265a.922.922 0 0 0 .92.92h.617V5.775l-.617.005ZM12.747 5.78c.508 0 .92.413.92.92v4.264a.923.923 0 0 1-.92.922h-.617V5.775l.617.004Z"
+			/>
+			<path
+				fill="#90A4AE"
+				d="M12.463 5.931 12.45 4.82a.867.867 0 0 0-.87-.861H7.34v-1.49a1.083 1.083 0 1 0-.68 0v1.496H2.42a.867.867 0 0 0-.864.86v7.976c.003.475.389.86.865.862h9.16a.868.868 0 0 0 .869-.862v-.82h.013v-6.05Z"
+			/>
+			<path
+				fill="#C62828"
+				d="M7 1.885a.444.444 0 1 1 0-.888.444.444 0 0 1 0 .888Z"
+			/>
+			<path
+				fill="url(#a)"
+				d="M4.795 10.379h4.412c.384 0 .696.312.696.697v.063a.697.697 0 0 1-.696.697H4.795a.697.697 0 0 1-.697-.697v-.063c0-.385.312-.697.697-.697Z"
+			/>
+			<path fill="url(#b)" d="M6.115 10.38h-.262v1.455h.262V10.38Z" />
+			<path fill="url(#c)" d="M7.138 10.38h-.262v1.455h.262V10.38Z" />
+			<path fill="url(#d)" d="M8.147 10.38h-.262v1.455h.262V10.38Z" />
+			<path fill="url(#e)" d="M9.22 10.38h-.262v1.455h.262V10.38Z" />
+			<path fill="url(#f)" d="M5.042 10.379H4.78v1.454h.262V10.38Z" />
+			<path
+				fill="#C62828"
+				d="M7 9.367h-.593a.111.111 0 0 1-.098-.162l.304-.6.288-.532a.11.11 0 0 1 .195 0l.29.556.301.576a.11.11 0 0 1-.098.162H7Z"
+			/>
+			<path
+				fill="url(#g)"
+				d="M4.627 8.587a1.278 1.278 0 1 0 0-2.556 1.278 1.278 0 0 0 0 2.556Z"
+			/>
+			<path
+				fill="url(#h)"
+				fillRule="evenodd"
+				d="M4.627 6.142a1.167 1.167 0 1 0 0 2.333 1.167 1.167 0 0 0 0-2.333ZM3.237 7.31a1.389 1.389 0 1 1 2.778 0 1.389 1.389 0 0 1-2.777 0Z"
+				clipRule="evenodd"
+			/>
+			<path
+				fill="url(#i)"
+				d="M9.333 6.028a1.278 1.278 0 1 0 0 2.556 1.278 1.278 0 0 0 0-2.556Z"
+			/>
+			<path
+				fill="url(#j)"
+				fillRule="evenodd"
+				d="M7.944 7.306a1.39 1.39 0 0 1 2.778 0 1.389 1.389 0 0 1-2.778 0Zm1.39-1.167a1.167 1.167 0 1 0 0 2.334 1.167 1.167 0 0 0 0-2.334Z"
+				clipRule="evenodd"
+			/>
+			<defs>
+				<linearGradient
+					id="a"
+					x1="7.001"
+					x2="7.001"
+					y1="11.836"
+					y2="10.379"
+					gradientUnits="userSpaceOnUse"
+				>
+					<stop offset=".12" stopColor="#E0E0E0" />
+					<stop offset=".52" stopColor="#fff" />
+					<stop offset="1" stopColor="#EAEAEA" />
+				</linearGradient>
+				<linearGradient
+					id="b"
+					x1="5.984"
+					x2="5.984"
+					y1="11.835"
+					y2="10.381"
+					gradientUnits="userSpaceOnUse"
+				>
+					<stop stopColor="#333" />
+					<stop offset=".55" stopColor="#666" />
+					<stop offset="1" stopColor="#333" />
+				</linearGradient>
+				<linearGradient
+					id="c"
+					x1="7.007"
+					x2="7.007"
+					y1="11.835"
+					y2="10.381"
+					gradientUnits="userSpaceOnUse"
+				>
+					<stop stopColor="#333" />
+					<stop offset=".55" stopColor="#666" />
+					<stop offset="1" stopColor="#333" />
+				</linearGradient>
+				<linearGradient
+					id="d"
+					x1="8.016"
+					x2="8.016"
+					y1="11.835"
+					y2="10.381"
+					gradientUnits="userSpaceOnUse"
+				>
+					<stop stopColor="#333" />
+					<stop offset=".55" stopColor="#666" />
+					<stop offset="1" stopColor="#333" />
+				</linearGradient>
+				<linearGradient
+					id="e"
+					x1="9.089"
+					x2="9.089"
+					y1="11.835"
+					y2="10.381"
+					gradientUnits="userSpaceOnUse"
+				>
+					<stop stopColor="#333" />
+					<stop offset=".55" stopColor="#666" />
+					<stop offset="1" stopColor="#333" />
+				</linearGradient>
+				<linearGradient
+					id="f"
+					x1="4.911"
+					x2="4.911"
+					y1="11.833"
+					y2="10.379"
+					gradientUnits="userSpaceOnUse"
+				>
+					<stop stopColor="#333" />
+					<stop offset=".55" stopColor="#666" />
+					<stop offset="1" stopColor="#333" />
+				</linearGradient>
+				<linearGradient
+					id="h"
+					x1="3.238"
+					x2="6.015"
+					y1="7.309"
+					y2="7.309"
+					gradientUnits="userSpaceOnUse"
+				>
+					<stop stopColor="#333" />
+					<stop offset=".55" stopColor="#666" />
+					<stop offset="1" stopColor="#333" />
+				</linearGradient>
+				<linearGradient
+					id="j"
+					x1="7.939"
+					x2="10.716"
+					y1="7.306"
+					y2="7.306"
+					gradientUnits="userSpaceOnUse"
+				>
+					<stop stopColor="#333" />
+					<stop offset=".55" stopColor="#666" />
+					<stop offset="1" stopColor="#333" />
+				</linearGradient>
+				<radialGradient
+					id="g"
+					cx="0"
+					cy="0"
+					r="1"
+					gradientTransform="matrix(1.27771 0 0 1.2777 4.627 7.309)"
+					gradientUnits="userSpaceOnUse"
+				>
+					<stop offset=".48" stopColor="#fff" />
+					<stop offset=".77" stopColor="#FDFDFD" />
+					<stop offset=".88" stopColor="#F6F6F6" />
+					<stop offset=".96" stopColor="#EBEBEB" />
+					<stop offset="1" stopColor="#E0E0E0" />
+				</radialGradient>
+				<radialGradient
+					id="i"
+					cx="0"
+					cy="0"
+					r="1"
+					gradientTransform="matrix(1.27771 0 0 1.2777 9.328 7.306)"
+					gradientUnits="userSpaceOnUse"
+				>
+					<stop offset=".48" stopColor="#fff" />
+					<stop offset=".77" stopColor="#FDFDFD" />
+					<stop offset=".88" stopColor="#F6F6F6" />
+					<stop offset=".96" stopColor="#EBEBEB" />
+					<stop offset="1" stopColor="#E0E0E0" />
+				</radialGradient>
+			</defs>
+		</svg>
+	);
+}
+
+export default ErrorIcon;

frontend/src/components/CeleryOverview/CeleryOverviewTable/CeleryOverviewTable.styles.scss

@@ -93,7 +93,7 @@
 			padding: 4px;
 			margin: 0;
 
-			// this is to offset intercom icon
+			// this is to offset chat support icon
 			padding-right: 72px;
 
 			.ant-pagination-item {

frontend/src/components/ChatSupportGateway/ChatSupportGateway.tsx

@@ -1,14 +1,14 @@
 import { Button, Modal, Typography } from 'antd';
-import updateCreditCardApi from 'api/billing/checkout';
 import logEvent from 'api/common/logEvent';
-import { SOMETHING_WENT_WRONG } from 'constants/api';
+import updateCreditCardApi from 'api/v1/checkout/create';
 import { useNotifications } from 'hooks/useNotifications';
-import { CreditCard, X } from 'lucide-react';
+import { CreditCard, MessageSquareText, X } from 'lucide-react';
 import { useState } from 'react';
 import { useMutation } from 'react-query';
 import { useLocation } from 'react-router-dom';
-import { ErrorResponse, SuccessResponse } from 'types/api';
+import { SuccessResponseV2 } from 'types/api';
 import { CheckoutSuccessPayloadProps } from 'types/api/billing/checkout';
+import APIError from 'types/api/error';
 
 export default function ChatSupportGateway(): JSX.Element {
 	const { notifications } = useNotifications();
@@ -18,20 +18,21 @@ export default function ChatSupportGateway(): JSX.Element {
 	);
 
 	const handleBillingOnSuccess = (
-		data: ErrorResponse | SuccessResponse<CheckoutSuccessPayloadProps, unknown>,
+		data: SuccessResponseV2<CheckoutSuccessPayloadProps>,
 	): void => {
-		if (data?.payload?.redirectURL) {
+		if (data?.data?.redirectURL) {
 			const newTab = document.createElement('a');
-			newTab.href = data.payload.redirectURL;
+			newTab.href = data.data.redirectURL;
 			newTab.target = '_blank';
 			newTab.rel = 'noopener noreferrer';
 			newTab.click();
 		}
 	};
 
-	const handleBillingOnError = (): void => {
+	const handleBillingOnError = (error: APIError): void => {
 		notifications.error({
-			message: SOMETHING_WENT_WRONG,
+			message: error.getErrorCode(),
+			description: error.getErrorMessage(),
 		});
 	};
 
@@ -48,7 +49,7 @@ export default function ChatSupportGateway(): JSX.Element {
 
 	const handleAddCreditCard = (): void => {
 		logEvent('Add Credit card modal: Clicked', {
-			source: `intercom icon`,
+			source: `chat support icon`,
 			page: pathname,
 		});
 
@@ -64,20 +65,14 @@ export default function ChatSupportGateway(): JSX.Element {
 					className="chat-support-gateway-btn"
 					onClick={(): void => {
 						logEvent('Disabled Chat Support: Clicked', {
-							source: `intercom icon`,
+							source: `chat support icon`,
 							page: pathname,
 						});
 
 						setIsAddCreditCardModalOpen(true);
 					}}
 				>
-					<svg
-						xmlns="http://www.w3.org/2000/svg"
-						viewBox="0 0 28 32"
-						className="chat-support-gateway-btn-icon"
-					>
-						<path d="M28 32s-4.714-1.855-8.527-3.34H3.437C1.54 28.66 0 27.026 0 25.013V3.644C0 1.633 1.54 0 3.437 0h21.125c1.898 0 3.437 1.632 3.437 3.645v18.404H28V32zm-4.139-11.982a.88.88 0 00-1.292-.105c-.03.026-3.015 2.681-8.57 2.681-5.486 0-8.517-2.636-8.571-2.684a.88.88 0 00-1.29.107 1.01 1.01 0 00-.219.708.992.992 0 00.318.664c.142.128 3.537 3.15 9.762 3.15 6.226 0 9.621-3.022 9.763-3.15a.992.992 0 00.317-.664 1.01 1.01 0 00-.218-.707z" />
-					</svg>
+					<MessageSquareText size={24} />
 				</Button>
 			</div>
 

frontend/src/components/ErrorModal/ErrorModal.styles.scss

@@ -0,0 +1,118 @@
+.error-modal {
+	&__trigger {
+		width: fit-content;
+		display: flex;
+		align-items: center;
+		gap: 4px;
+		border-radius: 20px;
+		background: rgba(229, 72, 77, 0.2);
+		padding-left: 3px;
+		padding-right: 8px;
+		cursor: pointer;
+		span {
+			color: var(--bg-cherry-500);
+			font-size: 10px;
+			font-weight: 500;
+			line-height: 20px; /* 200% */
+			letter-spacing: 0.4px;
+			text-transform: uppercase;
+		}
+	}
+	&__wrap {
+		background: linear-gradient(
+			180deg,
+			rgba(11, 12, 14, 0.12) 0.07%,
+			rgba(39, 8, 14, 0.24) 50.04%,
+			rgba(106, 29, 44, 0.36) 75.02%,
+			rgba(197, 57, 85, 0.48) 87.51%,
+			rgba(242, 71, 105, 0.6) 100%
+		);
+		-webkit-backdrop-filter: blur(10px);
+		backdrop-filter: blur(10px);
+
+		.ant-modal {
+			bottom: 40px;
+			top: unset;
+			position: absolute;
+			width: 520px;
+			left: 0px;
+			right: 0px;
+			margin: auto;
+		}
+	}
+	&__body {
+		padding: 0;
+		background: var(--bg-ink-400);
+		overflow: hidden;
+		border-top-left-radius: 4px;
+		border-top-right-radius: 4px;
+	}
+	&__header {
+		background: none !important;
+		.ant-modal-title {
+			display: flex;
+			justify-content: space-between;
+			align-items: center;
+		}
+		.key-value-label {
+			padding: 0;
+			border: none;
+			border-radius: 4px;
+			overflow: hidden;
+			&__key,
+			&__value {
+				padding: 4px 8px;
+				font-size: 12px;
+				font-style: normal;
+				font-weight: 500;
+				line-height: 16px;
+				letter-spacing: 0.48px;
+			}
+			&__key {
+				text-transform: uppercase;
+				&,
+				&:hover {
+					color: var(--bg-vanilla-100);
+				}
+			}
+			&__value {
+				color: var(--bg-vanilla-400);
+				pointer-events: none;
+			}
+		}
+		.close-button {
+			padding: 3px 7px;
+			background: var(--bg-ink-400);
+			display: inline-flex;
+			align-items: center;
+			border-radius: 4px;
+			border: 1px solid var(--bg-slate-500);
+			box-shadow: none;
+		}
+	}
+	&__footer {
+		margin: 0 !important;
+		height: 6px;
+		background: var(--bg-sakura-500);
+	}
+	&__content {
+		padding: 0 !important;
+		border-radius: 4px;
+		overflow: hidden;
+		background: none !important;
+	}
+}
+
+.lightMode {
+	.error-modal {
+		&__body,
+		&__header .close-button {
+			background: var(--bg-vanilla-100);
+		}
+		&__header .close-button {
+			svg {
+				fill: var(--bg-vanilla-100);
+			}
+		}
+	}
+}

frontend/src/components/ErrorModal/ErrorModal.test.tsx

@@ -0,0 +1,195 @@
+import { act, fireEvent, render, screen, waitFor } from 'tests/test-utils';
+import APIError from 'types/api/error';
+
+import ErrorModal from './ErrorModal';
+
+// Mock the query client to return version data
+const mockVersionData = {
+	payload: {
+		ee: 'Y',
+		version: '1.0.0',
+	},
+};
+jest.mock('react-query', () => ({
+	...jest.requireActual('react-query'),
+	useQueryClient: (): { getQueryData: () => typeof mockVersionData } => ({
+		getQueryData: jest.fn(() => mockVersionData),
+	}),
+}));
+const mockError: APIError = new APIError({
+	httpStatusCode: 400,
+	error: {
+		// eslint-disable-next-line sonarjs/no-duplicate-string
+		message: 'Something went wrong while processing your request.',
+		// eslint-disable-next-line sonarjs/no-duplicate-string
+		code: 'An error occurred',
+		// eslint-disable-next-line sonarjs/no-duplicate-string
+		url: 'https://example.com/docs',
+		errors: [
+			{ message: 'First error detail' },
+			{ message: 'Second error detail' },
+			{ message: 'Third error detail' },
+		],
+	},
+});
+describe('ErrorModal Component', () => {
+	it('should render the modal when open is true', () => {
+		render(<ErrorModal error={mockError} open onClose={jest.fn()} />);
+
+		// Check if the error message is displayed
+		expect(screen.getByText('An error occurred')).toBeInTheDocument();
+		expect(
+			screen.getByText('Something went wrong while processing your request.'),
+		).toBeInTheDocument();
+	});
+
+	it('should not render the modal when open is false', () => {
+		render(<ErrorModal error={mockError} open={false} onClose={jest.fn()} />);
+
+		// Check that the modal content is not in the document
+		expect(screen.queryByText('An error occurred')).not.toBeInTheDocument();
+	});
+
+	it('should call onClose when the close button is clicked', async () => {
+		const onCloseMock = jest.fn();
+		render(<ErrorModal error={mockError} open onClose={onCloseMock} />);
+
+		// Click the close button
+		const closeButton = screen.getByTestId('close-button');
+		act(() => {
+			fireEvent.click(closeButton);
+		});
+
+		// Check if onClose was called
+		expect(onCloseMock).toHaveBeenCalledTimes(1);
+	});
+
+	it('should display version data if available', async () => {
+		render(<ErrorModal error={mockError} open onClose={jest.fn()} />);
+
+		// Check if the version data is displayed
+		expect(screen.getByText('ENTERPRISE')).toBeInTheDocument();
+		expect(screen.getByText('1.0.0')).toBeInTheDocument();
+	});
+	it('should render the messages count badge when there are multiple errors', () => {
+		render(<ErrorModal error={mockError} open onClose={jest.fn()} />);
+
+		// Check if the messages count badge is displayed
+		expect(screen.getByText('MESSAGES')).toBeInTheDocument();
+
+		expect(screen.getByText('3')).toBeInTheDocument();
+
+		// Check if the individual error messages are displayed
+		expect(screen.getByText('First error detail')).toBeInTheDocument();
+		expect(screen.getByText('Second error detail')).toBeInTheDocument();
+		expect(screen.getByText('Third error detail')).toBeInTheDocument();
+	});
+
+	it('should render the open docs button when URL is provided', async () => {
+		render(<ErrorModal error={mockError} open onClose={jest.fn()} />);
+
+		// Check if the open docs button is displayed
+		const openDocsButton = screen.getByTestId('error-docs-button');
+
+		expect(openDocsButton).toBeInTheDocument();
+
+		expect(openDocsButton).toHaveAttribute('href', 'https://example.com/docs');
+
+		expect(openDocsButton).toHaveAttribute('target', '_blank');
+	});
+
+	it('should not display scroll for more if there are less than 10 messages', () => {
+		render(<ErrorModal error={mockError} open onClose={jest.fn()} />);
+
+		expect(screen.queryByText('Scroll for more')).not.toBeInTheDocument();
+	});
+	it('should display scroll for more if there are more than 10 messages', async () => {
+		const longError = new APIError({
+			httpStatusCode: 400,
+			error: {
+				...mockError.error,
+				code: 'An error occurred',
+				message: 'Something went wrong while processing your request.',
+				url: 'https://example.com/docs',
+				errors: Array.from({ length: 15 }, (_, i) => ({
+					message: `Error detail ${i + 1}`,
+				})),
+			},
+		});
+
+		render(<ErrorModal error={longError} open onClose={jest.fn()} />);
+
+		// Check if the scroll hint is displayed
+		expect(screen.getByText('Scroll for more')).toBeInTheDocument();
+	});
+});
+it('should render the trigger component if provided', () => {
+	const mockTrigger = <button type="button">Open Error Modal</button>;
+	render(
+		<ErrorModal
+			error={mockError}
+			triggerComponent={mockTrigger}
+			onClose={jest.fn()}
+		/>,
+	);
+
+	// Check if the trigger component is rendered
+	expect(screen.getByText('Open Error Modal')).toBeInTheDocument();
+});
+
+it('should open the modal when the trigger component is clicked', async () => {
+	const mockTrigger = <button type="button">Open Error Modal</button>;
+	render(
+		<ErrorModal
+			error={mockError}
+			triggerComponent={mockTrigger}
+			onClose={jest.fn()}
+		/>,
+	);
+
+	// Click the trigger component
+	const triggerButton = screen.getByText('Open Error Modal');
+	act(() => {
+		fireEvent.click(triggerButton);
+	});
+
+	// Check if the modal is displayed
+	expect(screen.getByText('An error occurred')).toBeInTheDocument();
+});
+
+it('should render the default trigger tag if no trigger component is provided', () => {
+	render(<ErrorModal error={mockError} onClose={jest.fn()} />);
+
+	// Check if the default trigger tag is rendered
+	expect(screen.getByText('error')).toBeInTheDocument();
+});
+
+it('should close the modal when the onCancel event is triggered', async () => {
+	const onCloseMock = jest.fn();
+	render(<ErrorModal error={mockError} onClose={onCloseMock} />);
+
+	// Click the trigger component
+	const triggerButton = screen.getByText('error');
+	act(() => {
+		fireEvent.click(triggerButton);
+	});
+
+	await waitFor(() => {
+		expect(screen.getByText('An error occurred')).toBeInTheDocument();
+	});
+
+	// Trigger the onCancel event
+	act(() => {
+		fireEvent.click(screen.getByTestId('close-button'));
+	});
+
+	// Check if the modal is closed
+	expect(onCloseMock).toHaveBeenCalledTimes(1);
+
+	await waitFor(() => {
+		// check if the modal is not visible
+		const modal = document.getElementsByClassName('ant-modal');
+		const style = window.getComputedStyle(modal[0]);
+		expect(style.display).toBe('none');
+	});
+});

frontend/src/components/ErrorModal/ErrorModal.tsx

@@ -0,0 +1,102 @@
+import './ErrorModal.styles.scss';
+
+import { Color } from '@signozhq/design-tokens';
+import { Button, Modal, Tag } from 'antd';
+import { CircleAlert, X } from 'lucide-react';
+import KeyValueLabel from 'periscope/components/KeyValueLabel';
+import { useAppContext } from 'providers/App/App';
+import React from 'react';
+import APIError from 'types/api/error';
+
+import ErrorContent from './components/ErrorContent';
+
+type Props = {
+	error: APIError;
+	triggerComponent?: React.ReactElement;
+	onClose?: () => void;
+	open?: boolean;
+};
+
+const classNames = {
+	body: 'error-modal__body',
+	mask: 'error-modal__mask',
+	header: 'error-modal__header',
+	footer: 'error-modal__footer',
+	content: 'error-modal__content',
+};
+
+function ErrorModal({
+	open,
+	error,
+	triggerComponent,
+	onClose,
+}: Props): JSX.Element {
+	const [visible, setVisible] = React.useState(open);
+
+	const handleClose = (): void => {
+		setVisible(false);
+		onClose?.();
+	};
+
+	const { versionData } = useAppContext();
+
+	const versionDataPayload = versionData;
+
+	return (
+		<>
+			{!triggerComponent ? (
+				<Tag
+					className="error-modal__trigger"
+					icon={<CircleAlert size={14} color={Color.BG_CHERRY_500} />}
+					color="error"
+					onClick={(): void => setVisible(true)}
+				>
+					error
+				</Tag>
+			) : (
+				React.cloneElement(triggerComponent, {
+					onClick: () => setVisible(true),
+				})
+			)}
+
+			<Modal
+				open={visible}
+				footer={<div className="error-modal__footer" />}
+				title={
+					<>
+						{versionDataPayload ? (
+							<KeyValueLabel
+								badgeKey={versionDataPayload.ee === 'Y' ? 'ENTERPRISE' : 'COMMUNITY'}
+								badgeValue={versionDataPayload.version}
+							/>
+						) : (
+							<div className="error-modal__version-placeholder" />
+						)}
+						<Button
+							type="default"
+							className="close-button"
+							onClick={handleClose}
+							data-testid="close-button"
+						>
+							<X size={16} color={Color.BG_VANILLA_400} />
+						</Button>
+					</>
+				}
+				onCancel={handleClose}
+				closeIcon={false}
+				classNames={classNames}
+				wrapClassName="error-modal__wrap"
+			>
+				<ErrorContent error={error} />
+			</Modal>
+		</>
+	);
+}
+
+ErrorModal.defaultProps = {
+	onClose: undefined,
+	triggerComponent: null,
+	open: false,
+};
+
+export default ErrorModal;

frontend/src/components/ErrorModal/components/ErrorContent.styles.scss

@@ -0,0 +1,208 @@
+.error-content {
+	display: flex;
+	flex-direction: column;
+	// === SECTION: Summary (Top)
+	&__summary-section {
+		display: flex;
+		flex-direction: column;
+		border-bottom: 1px solid var(--bg-slate-400);
+	}
+
+	&__summary {
+		display: flex;
+		justify-content: space-between;
+		padding: 16px;
+	}
+
+	&__summary-left {
+		display: flex;
+		align-items: baseline;
+		gap: 8px;
+	}
+
+	&__summary-text {
+		display: flex;
+		flex-direction: column;
+		gap: 6px;
+	}
+
+	&__error-code {
+		color: var(--bg-vanilla-100);
+		margin: 0;
+		font-size: 16px;
+		font-weight: 500;
+		line-height: 24px; /* 150% */
+		letter-spacing: -0.08px;
+	}
+
+	&__error-message {
+		margin: 0;
+		color: var(--bg-vanilla-400);
+		font-size: 14px;
+		font-weight: 400;
+		line-height: 20px; /* 142.857% */
+		letter-spacing: -0.07px;
+	}
+
+	&__docs-button {
+		display: flex;
+		align-items: center;
+		gap: 6px;
+		padding: 9px 12.5px;
+		color: var(--bg-vanilla-400);
+		font-size: 12px;
+		font-weight: 400;
+		line-height: 18px; /* 150% */
+		letter-spacing: 0.12px;
+		border-radius: 2px;
+		border: 1px solid var(--bg-slate-400);
+		background: var(--bg-ink-300);
+		box-shadow: none;
+	}
+
+	&__message-badge {
+		display: flex;
+		align-items: center;
+		gap: 12px;
+		padding: 0px 16px 16px;
+
+		.key-value-label {
+			width: fit-content;
+			border-color: var(--bg-slate-400);
+			border-radius: 20px;
+			overflow: hidden;
+			&__key {
+				padding-left: 8px;
+				padding-right: 8px;
+			}
+			&__value {
+				padding-right: 10px;
+				color: var(--bg-vanilla-400);
+				font-size: 12px;
+				font-weight: 500;
+				line-height: 18px; /* 150% */
+				letter-spacing: 0.48px;
+				pointer-events: none;
+			}
+		}
+		&-label {
+			display: flex;
+			align-items: center;
+			gap: 6px;
+			&-dot {
+				height: 6px;
+				width: 6px;
+				background: var(--bg-sakura-500);
+				border-radius: 50%;
+			}
+			&-text {
+				color: var(--bg-vanilla-100);
+				font-size: 10px;
+				font-weight: 500;
+				line-height: 18px; /* 180% */
+				letter-spacing: 0.5px;
+			}
+		}
+		&-line {
+			flex: 1;
+			height: 8px;
+			background-image: radial-gradient(circle, #444c63 1px, transparent 2px);
+			background-size: 8px 11px;
+			background-position: top left;
+			padding: 6px;
+		}
+	}
+
+	// === SECTION: Message List (Bottom)
+
+	&__message-list-container {
+		position: relative;
+	}
+
+	&__message-list {
+		margin: 0;
+		padding: 0;
+		list-style: none;
+		max-height: 275px;
+	}
+
+	&__message-item {
+		position: relative;
+		margin-bottom: 4px;
+		color: var(--bg-vanilla-400);
+		font-family: Geist Mono;
+		font-size: 12px;
+		font-weight: 400;
+		line-height: 18px;
+		color: var(--bg-vanilla-400);
+		padding: 3px 12px;
+		padding-left: 26px;
+	}
+
+	&__message-item::before {
+		font-family: unset;
+		content: '';
+		position: absolute;
+		left: 12px;
+		top: 50%;
+		transform: translateY(-50%);
+		width: 2px;
+		height: 4px;
+		border-radius: 50px;
+		background: var(--bg-slate-400);
+	}
+
+	&__scroll-hint {
+		position: absolute;
+		bottom: 10px;
+		left: 0px;
+		right: 0px;
+		margin: auto;
+		width: fit-content;
+		display: inline-flex;
+		padding: 4px 12px 4px 10px;
+		justify-content: center;
+		align-items: center;
+		gap: 3px;
+		background: var(--bg-slate-200);
+		border-radius: 20px;
+		box-shadow: 0px 103px 12px 0px rgba(0, 0, 0, 0.01),
+			0px 66px 18px 0px rgba(0, 0, 0, 0.01), 0px 37px 22px 0px rgba(0, 0, 0, 0.03),
+			0px 17px 17px 0px rgba(0, 0, 0, 0.04), 0px 4px 9px 0px rgba(0, 0, 0, 0.04);
+	}
+
+	&__scroll-hint-text {
+		color: var(--bg-vanilla-100);
+
+		font-size: 12px;
+		font-weight: 400;
+		line-height: 18px;
+		letter-spacing: -0.06px;
+	}
+}
+
+.lightMode {
+	.error-content {
+		&__error-code {
+			color: var(--bg-ink-100);
+		}
+		&__error-message {
+			color: var(--bg-ink-400);
+		}
+		&__message-item {
+			color: var(--bg-ink-400);
+		}
+		&__message-badge {
+			&-label-text {
+				color: var(--bg-ink-400);
+			}
+			.key-value-label__value {
+				color: var(--bg-ink-400);
+			}
+		}
+		&__docs-button {
+			background: var(--bg-vanilla-100);
+			color: var(--bg-ink-100);
+		}
+	}
+}

frontend/src/components/ErrorModal/components/ErrorContent.tsx

@@ -0,0 +1,98 @@
+import './ErrorContent.styles.scss';
+
+import { Color } from '@signozhq/design-tokens';
+import { Button } from 'antd';
+import ErrorIcon from 'assets/Error';
+import OverlayScrollbar from 'components/OverlayScrollbar/OverlayScrollbar';
+import { BookOpenText, ChevronsDown } from 'lucide-react';
+import KeyValueLabel from 'periscope/components/KeyValueLabel';
+import APIError from 'types/api/error';
+
+interface ErrorContentProps {
+	error: APIError;
+}
+
+function ErrorContent({ error }: ErrorContentProps): JSX.Element {
+	const {
+		url: errorUrl,
+		errors: errorMessages,
+		code: errorCode,
+		message: errorMessage,
+	} = error.error.error;
+	return (
+		<section className="error-content">
+			{/* Summary Header */}
+			<section className="error-content__summary-section">
+				<header className="error-content__summary">
+					<div className="error-content__summary-left">
+						<div className="error-content__icon-wrapper">
+							<ErrorIcon />
+						</div>
+
+						<div className="error-content__summary-text">
+							<h2 className="error-content__error-code">{errorCode}</h2>
+							<p className="error-content__error-message">{errorMessage}</p>
+						</div>
+					</div>
+
+					{errorUrl && (
+						<div className="error-content__summary-right">
+							<Button
+								type="default"
+								className="error-content__docs-button"
+								href={errorUrl}
+								target="_blank"
+								data-testid="error-docs-button"
+							>
+								<BookOpenText size={14} />
+								Open Docs
+							</Button>
+						</div>
+					)}
+				</header>
+
+				{errorMessages?.length > 0 && (
+					<div className="error-content__message-badge">
+						<KeyValueLabel
+							badgeKey={
+								<div className="error-content__message-badge-label">
+									<div className="error-content__message-badge-label-dot" />
+									<div className="error-content__message-badge-label-text">MESSAGES</div>
+								</div>
+							}
+							badgeValue={errorMessages.length.toString()}
+						/>
+						<div className="error-content__message-badge-line" />
+					</div>
+				)}
+			</section>
+
+			{/* Detailed Messages */}
+			<section className="error-content__messages-section">
+				<div className="error-content__message-list-container">
+					<OverlayScrollbar>
+						<ul className="error-content__message-list">
+							{errorMessages?.map((error) => (
+								<li className="error-content__message-item" key={error.message}>
+									{error.message}
+								</li>
+							))}
+						</ul>
+					</OverlayScrollbar>
+					{errorMessages?.length > 10 && (
+						<div className="error-content__scroll-hint">
+							<ChevronsDown
+								size={16}
+								color={Color.BG_VANILLA_100}
+								className="error-content__scroll-hint-icon"
+							/>
+							<span className="error-content__scroll-hint-text">Scroll for more</span>
+						</div>
+					)}
+				</div>
+			</section>
+		</section>
+	);
+}
+
+export default ErrorContent;

frontend/src/components/HostMetricsDetail/HostMetricsDetails.tsx

@@ -37,6 +37,7 @@ import {
 } from 'lucide-react';
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { AppState } from 'store/reducers';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import {
@@ -67,6 +68,7 @@ function HostMetricsDetails({
 		AppState,
 		GlobalReducer
 	>((state) => state.globalTime);
+	const [searchParams, setSearchParams] = useSearchParams();
 
 	const startMs = useMemo(() => Math.floor(Number(minTime) / 1000000000), [
 		minTime,
@@ -86,7 +88,9 @@ function HostMetricsDetails({
 		selectedTime as Time,
 	);
 
-	const [selectedView, setSelectedView] = useState<VIEWS>(VIEWS.METRICS);
+	const [selectedView, setSelectedView] = useState<VIEWS>(
+		(searchParams.get('view') as VIEWS) || VIEWS.METRICS,
+	);
 	const isDarkMode = useIsDarkMode();
 
 	const initialFilters = useMemo(
@@ -149,6 +153,9 @@ function HostMetricsDetails({
 
 	const handleTabChange = (e: RadioChangeEvent): void => {
 		setSelectedView(e.target.value);
+		if (host?.hostName) {
+			setSearchParams({ hostName: host?.hostName, view: e.target.value });
+		}
 		logEvent(InfraMonitoringEvents.TabChanged, {
 			entity: InfraMonitoringEvents.HostEntity,
 			view: e.target.value,
@@ -313,6 +320,7 @@ function HostMetricsDetails({
 
 	const handleClose = (): void => {
 		setSelectedInterval(selectedTime as Time);
+		setSearchParams({});
 
 		if (selectedTime !== 'custom') {
 			const { maxTime, minTime } = GetMinMax(selectedTime);

frontend/src/components/HostMetricsDetail/HostMetricsLogs/HostMetricLogsDetailedView.tsx

@@ -87,11 +87,7 @@ function HostMetricLogsDetailedView({
 					/>
 				</div>
 			</div>
-			<HostMetricsLogs
-				timeRange={timeRange}
-				handleChangeLogFilters={handleChangeLogFilters}
-				filters={logFilters}
-			/>
+			<HostMetricsLogs timeRange={timeRange} filters={logFilters} />
 		</div>
 	);
 }

frontend/src/components/HostMetricsDetail/HostMetricsLogs/HostMetricsLogs.tsx

@@ -8,19 +8,13 @@ import { DEFAULT_ENTITY_VERSION } from 'constants/app';
 import LogsError from 'container/LogsError/LogsError';
 import { LogsLoading } from 'container/LogsLoading/LogsLoading';
 import { FontSize } from 'container/OptionsMenu/types';
-import { ORDERBY_FILTERS } from 'container/QueryBuilder/filters/OrderByFilter/config';
+import { useHandleLogsPagination } from 'hooks/infraMonitoring/useHandleLogsPagination';
 import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
-import { isEqual } from 'lodash-es';
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo } from 'react';
 import { useQuery } from 'react-query';
 import { Virtuoso } from 'react-virtuoso';
 import { ILog } from 'types/api/logs/log';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import {
-	IBuilderQuery,
-	TagFilterItem,
-} from 'types/api/queryBuilder/queryBuilderData';
-import { v4 } from 'uuid';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 
 import { getHostLogsQueryPayload } from './constants';
 import NoLogsContainer from './NoLogsContainer';
@@ -30,51 +24,30 @@ interface Props {
 		startTime: number;
 		endTime: number;
 	};
-	handleChangeLogFilters: (filters: IBuilderQuery['filters']) => void;
 	filters: IBuilderQuery['filters'];
 }
 
-function HostMetricsLogs({
-	timeRange,
-	handleChangeLogFilters,
-	filters,
-}: Props): JSX.Element {
-	const [logs, setLogs] = useState<ILog[]>([]);
-	const [hasReachedEndOfLogs, setHasReachedEndOfLogs] = useState(false);
-	const [restFilters, setRestFilters] = useState<TagFilterItem[]>([]);
-	const [resetLogsList, setResetLogsList] = useState<boolean>(false);
-
-	useEffect(() => {
-		const newRestFilters = filters.items.filter(
-			(item) => item.key?.key !== 'id' && item.key?.key !== 'host.name',
-		);
-
-		const areFiltersSame = isEqual(restFilters, newRestFilters);
-
-		if (!areFiltersSame) {
-			setResetLogsList(true);
-		}
-
-		setRestFilters(newRestFilters);
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [filters]);
-
-	const queryPayload = useMemo(() => {
-		const basePayload = getHostLogsQueryPayload(
-			timeRange.startTime,
-			timeRange.endTime,
-			filters,
-		);
-
-		basePayload.query.builder.queryData[0].pageSize = 100;
-		basePayload.query.builder.queryData[0].orderBy = [
-			{ columnName: 'timestamp', order: ORDERBY_FILTERS.DESC },
-		];
-
-		return basePayload;
-	}, [timeRange.startTime, timeRange.endTime, filters]);
-
-	const [isPaginating, setIsPaginating] = useState(false);
+function HostMetricsLogs({ timeRange, filters }: Props): JSX.Element {
+	const basePayload = getHostLogsQueryPayload(
+		timeRange.startTime,
+		timeRange.endTime,
+		filters,
+	);
+	const {
+		logs,
+		hasReachedEndOfLogs,
+		isPaginating,
+		currentPage,
+		setIsPaginating,
+		handleNewData,
+		loadMoreLogs,
+		queryPayload,
+	} = useHandleLogsPagination({
+		timeRange,
+		filters,
+		excludeFilterKeys: ['host.name'],
+		basePayload,
+	});
 
 	const { data, isLoading, isFetching, isError } = useQuery({
 		queryKey: [
@@ -82,6 +55,7 @@ function HostMetricsLogs({
 			timeRange.startTime,
 			timeRange.endTime,
 			filters,
+			currentPage,
 		],
 		queryFn: () => GetMetricQueryRange(queryPayload, DEFAULT_ENTITY_VERSION),
 		enabled: !!queryPayload,
@@ -90,38 +64,17 @@ function HostMetricsLogs({
 
 	useEffect(() => {
 		if (data?.payload?.data?.newResult?.data?.result) {
-			const currentData = data.payload.data.newResult.data.result;
-
-			if (resetLogsList) {
-				const currentLogs: ILog[] =
-					currentData[0].list?.map((item) => ({
-						...item.data,
-						timestamp: item.timestamp,
-					})) || [];
-
-				setLogs(currentLogs);
-
-				setResetLogsList(false);
-			}
-
-			if (currentData.length > 0 && currentData[0].list) {
-				const currentLogs: ILog[] =
-					currentData[0].list.map((item) => ({
-						...item.data,
-						timestamp: item.timestamp,
-					})) || [];
-
-				setLogs((prev) => [...prev, ...currentLogs]);
-			} else {
-				setHasReachedEndOfLogs(true);
-			}
+			handleNewData(data.payload.data.newResult.data.result);
 		}
-	}, [data, restFilters, isPaginating, resetLogsList]);
+	}, [data, handleNewData]);
+
+	useEffect(() => {
+		setIsPaginating(false);
+	}, [data, setIsPaginating]);
 
 	const getItemContent = useCallback(
 		(_: number, logToRender: ILog): JSX.Element => (
 			<RawLogView
-				isReadOnly
 				isTextOverflowEllipsisDisabled
 				key={logToRender.id}
 				data={logToRender}
@@ -144,39 +97,6 @@ function HostMetricsLogs({
 		[],
 	);
 
-	const loadMoreLogs = useCallback(() => {
-		if (!logs.length) return;
-
-		setIsPaginating(true);
-		const lastLog = logs[logs.length - 1];
-
-		const newItems = [
-			...filters.items.filter((item) => item.key?.key !== 'id'),
-			{
-				id: v4(),
-				key: {
-					key: 'id',
-					type: '',
-					dataType: DataTypes.String,
-					isColumn: true,
-				},
-				op: '<',
-				value: lastLog.id,
-			},
-		];
-
-		const newFilters = {
-			op: 'AND',
-			items: newItems,
-		} as IBuilderQuery['filters'];
-
-		handleChangeLogFilters(newFilters);
-	}, [logs, filters, handleChangeLogFilters]);
-
-	useEffect(() => {
-		setIsPaginating(false);
-	}, [data]);
-
 	const renderFooter = useCallback(
 		(): JSX.Element | null => (
 			// eslint-disable-next-line react/jsx-no-useless-fragment

frontend/src/components/HostMetricsDetail/HostMetricsLogs/__tests__/HostMetricsLogs.test.tsx

@@ -0,0 +1,168 @@
+import { ENVIRONMENT } from 'constants/env';
+import {
+	verifyFiltersAndOrderBy,
+	verifyPayload,
+} from 'container/LogsExplorerViews/tests/LogsExplorerPagination.test';
+import { logsPaginationQueryRangeSuccessResponse } from 'mocks-server/__mockdata__/logs_query_range';
+import { server } from 'mocks-server/server';
+import { rest } from 'msw';
+import { VirtuosoMockContext } from 'react-virtuoso';
+import {
+	act,
+	fireEvent,
+	render,
+	RenderResult,
+	waitFor,
+} from 'tests/test-utils';
+import { QueryRangePayload } from 'types/api/metrics/getQueryRange';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+
+import HostMetricsLogs from '../HostMetricsLogs';
+
+jest.mock('uplot', () => {
+	const paths = {
+		spline: jest.fn(),
+		bars: jest.fn(),
+	};
+	const uplotMock = jest.fn(() => ({
+		paths,
+	}));
+	return {
+		paths,
+		default: uplotMock,
+	};
+});
+
+jest.mock(
+	'components/OverlayScrollbar/OverlayScrollbar',
+	() =>
+		function MockOverlayScrollbar({
+			children,
+		}: {
+			children: React.ReactNode;
+		}): JSX.Element {
+			return <div>{children}</div>;
+		},
+);
+
+describe.skip('HostMetricsLogs', () => {
+	let capturedQueryRangePayloads: QueryRangePayload[] = [];
+	const itemHeight = 100;
+	beforeEach(() => {
+		server.use(
+			rest.post(
+				`${ENVIRONMENT.baseURL}/api/v3/query_range`,
+				async (req, res, ctx) => {
+					capturedQueryRangePayloads.push(await req.json());
+
+					const lastPayload =
+						capturedQueryRangePayloads[capturedQueryRangePayloads.length - 1];
+
+					const queryData = lastPayload?.compositeQuery.builderQueries
+						?.A as IBuilderQuery;
+
+					const offset = queryData?.offset ?? 0;
+
+					return res(
+						ctx.status(200),
+						ctx.json(logsPaginationQueryRangeSuccessResponse({ offset })),
+					);
+				},
+			),
+		);
+		capturedQueryRangePayloads = [];
+	});
+	it('should check if host logs pagination flows work properly', async () => {
+		let renderResult: RenderResult;
+		let scrollableElement: HTMLElement;
+
+		await act(async () => {
+			renderResult = render(
+				<VirtuosoMockContext.Provider value={{ viewportHeight: 500, itemHeight }}>
+					<HostMetricsLogs
+						timeRange={{ startTime: 0, endTime: 0 }}
+						filters={{ items: [], op: 'AND' }}
+					/>
+				</VirtuosoMockContext.Provider>,
+			);
+		});
+
+		await waitFor(() => {
+			expect(capturedQueryRangePayloads.length).toBe(1);
+		});
+
+		await waitFor(async () => {
+			// Find the Virtuoso scroller element by its data-test-id
+			scrollableElement = renderResult.container.querySelector(
+				'[data-test-id="virtuoso-scroller"]',
+			) as HTMLElement;
+
+			// Ensure the element exists
+			expect(scrollableElement).not.toBeNull();
+
+			if (scrollableElement) {
+				// Set the scrollTop property to simulate scrolling to the calculated end position
+				scrollableElement.scrollTop = 99 * itemHeight;
+
+				act(() => {
+					fireEvent.scroll(scrollableElement);
+				});
+			}
+		});
+
+		await waitFor(() => {
+			expect(capturedQueryRangePayloads.length).toBe(2);
+		});
+
+		const firstPayload = capturedQueryRangePayloads[0];
+		verifyPayload({
+			payload: firstPayload,
+			expectedOffset: 0,
+		});
+
+		// Store the time range from the first payload, which should be consistent in subsequent requests
+		const initialTimeRange = {
+			start: firstPayload.start,
+			end: firstPayload.end,
+		};
+
+		const secondPayload = capturedQueryRangePayloads[1];
+		const secondQueryData = verifyPayload({
+			payload: secondPayload,
+			expectedOffset: 100,
+			initialTimeRange,
+		});
+		verifyFiltersAndOrderBy(secondQueryData);
+
+		await waitFor(async () => {
+			// Find the Virtuoso scroller element by its data-test-id
+			scrollableElement = renderResult.container.querySelector(
+				'[data-test-id="virtuoso-scroller"]',
+			) as HTMLElement;
+
+			// Ensure the element exists
+			expect(scrollableElement).not.toBeNull();
+
+			if (scrollableElement) {
+				// Set the scrollTop property to simulate scrolling to the calculated end position
+				scrollableElement.scrollTop = 199 * itemHeight;
+
+				act(() => {
+					fireEvent.scroll(scrollableElement);
+				});
+			}
+		});
+
+		await waitFor(() => {
+			expect(capturedQueryRangePayloads.length).toBeGreaterThanOrEqual(3);
+		});
+
+		const thirdPayload = capturedQueryRangePayloads[2];
+		const thirdQueryData = verifyPayload({
+			payload: thirdPayload,
+			expectedOffset: 200,
+			initialTimeRange,
+		});
+		verifyFiltersAndOrderBy(thirdQueryData);
+	});
+});

frontend/src/components/HostMetricsDetail/HostMetricsLogs/constants.ts

@@ -57,9 +57,6 @@ export const getHostLogsQueryPayload = (
 		id: uuidv4(),
 		queryType: EQueryType.QUERY_BUILDER,
 	},
-	params: {
-		lastLogLineTimestamp: null,
-	},
 	start,
 	end,
 });

frontend/src/components/HostMetricsDetail/Metrics/Metrics.tsx

@@ -80,6 +80,7 @@ function Metrics({
 					softMin: null,
 					minTimeScale: timeRange.startTime,
 					maxTimeScale: timeRange.endTime,
+					enableZoom: true,
 				}),
 			),
 		[queries, isDarkMode, dimensions, timeRange.startTime, timeRange.endTime],
@@ -115,7 +116,7 @@ function Metrics({
 			<div className="metrics-header">
 				<div className="metrics-datetime-section">
 					<DateTimeSelectionV2
-						showAutoRefresh={false}
+						showAutoRefresh
 						showRefreshText={false}
 						hideShareModal
 						onTimeChange={handleTimeChange}

frontend/src/components/LaunchChatSupport/LaunchChatSupport.tsx

@@ -1,10 +1,9 @@
 import './LaunchChatSupport.styles.scss';
 
 import { Button, Modal, Tooltip, Typography } from 'antd';
-import updateCreditCardApi from 'api/billing/checkout';
 import logEvent from 'api/common/logEvent';
+import updateCreditCardApi from 'api/v1/checkout/create';
 import cx from 'classnames';
-import { SOMETHING_WENT_WRONG } from 'constants/api';
 import { FeatureKeys } from 'constants/features';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { useNotifications } from 'hooks/useNotifications';
@@ -14,8 +13,9 @@ import { useAppContext } from 'providers/App/App';
 import { useMemo, useState } from 'react';
 import { useMutation } from 'react-query';
 import { useLocation } from 'react-router-dom';
-import { ErrorResponse, SuccessResponse } from 'types/api';
+import { SuccessResponseV2 } from 'types/api';
 import { CheckoutSuccessPayloadProps } from 'types/api/billing/checkout';
+import APIError from 'types/api/error';
 
 export interface LaunchChatSupportProps {
 	eventName: string;
@@ -24,7 +24,7 @@ export interface LaunchChatSupportProps {
 	buttonText?: string;
 	className?: string;
 	onHoverText?: string;
-	intercomMessageDisabled?: boolean;
+	chatMessageDisabled?: boolean;
 }
 
 // eslint-disable-next-line sonarjs/cognitive-complexity
@@ -35,7 +35,7 @@ function LaunchChatSupport({
 	buttonText = '',
 	className = '',
 	onHoverText = '',
-	intercomMessageDisabled = false,
+	chatMessageDisabled = false,
 }: LaunchChatSupportProps): JSX.Element | null {
 	const { isCloudUser: isCloudUserVal } = useGetTenantLicense();
 	const { notifications } = useNotifications();
@@ -111,27 +111,30 @@ function LaunchChatSupport({
 			setIsAddCreditCardModalOpen(true);
 		} else {
 			logEvent(eventName, attributes);
-			if (window.Intercom && !intercomMessageDisabled) {
-				window.Intercom('showNewMessage', defaultTo(message, ''));
+			if (window.pylon && !chatMessageDisabled) {
+				// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+				// @ts-ignore
+				window.Pylon('showNewMessage', defaultTo(message, ''));
 			}
 		}
 	};
 
 	const handleBillingOnSuccess = (
-		data: ErrorResponse | SuccessResponse<CheckoutSuccessPayloadProps, unknown>,
+		data: SuccessResponseV2<CheckoutSuccessPayloadProps>,
 	): void => {
-		if (data?.payload?.redirectURL) {
+		if (data?.data?.redirectURL) {
 			const newTab = document.createElement('a');
-			newTab.href = data.payload.redirectURL;
+			newTab.href = data.data.redirectURL;
 			newTab.target = '_blank';
 			newTab.rel = 'noopener noreferrer';
 			newTab.click();
 		}
 	};
 
-	const handleBillingOnError = (): void => {
+	const handleBillingOnError = (error: APIError): void => {
 		notifications.error({
-			message: SOMETHING_WENT_WRONG,
+			message: error.getErrorCode(),
+			description: error.getErrorMessage(),
 		});
 	};
 
@@ -219,7 +222,7 @@ LaunchChatSupport.defaultProps = {
 	buttonText: '',
 	className: '',
 	onHoverText: '',
-	intercomMessageDisabled: false,
+	chatMessageDisabled: false,
 };
 
 export default LaunchChatSupport;