Add Mastra doc and update onboarding configuration (#9372)

* fix: make the trace details attributes search visible by default

* fix: make the attributes search focusable when the search button is toggled, not by default

* fix: don't display search in events tab of span details side drawer in empty state

* chore: write tests

* chore: mock signozhq/button

* chore: minor state rename

.devenv/docker/clickhouse/compose.yaml

@@ -42,7 +42,7 @@ services:
       timeout: 5s
       retries: 3
   schema-migrator-sync:
-    image: signoz/signoz-schema-migrator:v0.129.6
+    image: signoz/signoz-schema-migrator:v0.129.7
     container_name: schema-migrator-sync
     command:
       - sync
@@ -55,7 +55,7 @@ services:
         condition: service_healthy
     restart: on-failure
   schema-migrator-async:
-    image: signoz/signoz-schema-migrator:v0.129.6
+    image: signoz/signoz-schema-migrator:v0.129.7
     container_name: schema-migrator-async
     command:
       - async

.github/CODEOWNERS

@@ -48,13 +48,13 @@
 .github @SigNoz/devops
 
 # Scaffold Owners
-/pkg/config/ @grandwizard28
-/pkg/errors/ @grandwizard28
-/pkg/factory/ @grandwizard28
-/pkg/types/ @grandwizard28
-/pkg/valuer/ @grandwizard28
-/cmd/ @grandwizard28
-.golangci.yml @grandwizard28
+/pkg/config/ @therealpandey
+/pkg/errors/ @therealpandey
+/pkg/factory/ @therealpandey
+/pkg/types/ @therealpandey
+/pkg/valuer/ @therealpandey
+/cmd/ @therealpandey
+.golangci.yml @therealpandey
 
 # Zeus Owners
 /pkg/zeus/ @vikrantgupta25
@@ -84,4 +84,4 @@
 
 # AuthN / AuthZ Owners 
 
-/pkg/authz/ @vikrantgupta25 @grandwizard28
+/pkg/authz/ @vikrantgupta25 @therealpandey

.github/workflows/integrationci.yaml

@@ -15,15 +15,17 @@ jobs:
       matrix:
         src:
           - bootstrap
-          - auth
+          - passwordauthn
+          - callbackauthn
           - querier
+          - ttl
         sqlstore-provider:
           - postgres
           - sqlite
         clickhouse-version:
           - 25.5.6
         schema-migrator-version:
-          - v0.129.6
+          - v0.129.7
         postgres-version:
           - 15
     if: |
@@ -42,6 +44,20 @@ jobs:
           python -m pip install poetry==2.1.2
           python -m poetry config virtualenvs.in-project true
           cd tests/integration && poetry install --no-root
+      - name: webdriver
+        run: |
+          wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | sudo apt-key add -
+          echo "deb http://dl.google.com/linux/chrome/deb/ stable main" | sudo tee -a /etc/apt/sources.list.d/google-chrome.list
+          sudo apt-get update -qqy
+          sudo apt-get -qqy install google-chrome-stable
+          CHROME_VERSION=$(google-chrome-stable --version)
+          CHROME_FULL_VERSION=${CHROME_VERSION%%.*}
+          CHROME_MAJOR_VERSION=${CHROME_FULL_VERSION//[!0-9]}
+          sudo rm /etc/apt/sources.list.d/google-chrome.list
+          export CHROMEDRIVER_VERSION=`curl -s https://googlechromelabs.github.io/chrome-for-testing/LATEST_RELEASE_${CHROME_MAJOR_VERSION%%.*}`
+          curl -L -O "https://storage.googleapis.com/chrome-for-testing-public/${CHROMEDRIVER_VERSION}/linux64/chromedriver-linux64.zip"
+          unzip chromedriver-linux64.zip && chmod +x chromedriver && sudo mv chromedriver /usr/local/bin
+          chromedriver -version
       - name: run
         run: |
           cd tests/integration && \

README.md

@@ -236,7 +236,7 @@ Not sure how to get started? Just ping us on `#contributing` in our [slack commu
 #### DevOps
 
 - [Prashant Shahi](https://github.com/prashant-shahi)
-- [Vibhu Pandey](https://github.com/grandwizard28)
+- [Vibhu Pandey](https://github.com/therealpandey)
 
 <br /><br />
 

cmd/community/server.go

@@ -3,11 +3,11 @@ package main
 import (
 	"context"
 	"log/slog"
-	"time"
 
 	"github.com/SigNoz/signoz/cmd"
 	"github.com/SigNoz/signoz/ee/sqlstore/postgressqlstore"
 	"github.com/SigNoz/signoz/pkg/analytics"
+	"github.com/SigNoz/signoz/pkg/authn"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/licensing"
 	"github.com/SigNoz/signoz/pkg/licensing/nooplicensing"
@@ -56,12 +56,9 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 		return err
 	}
 
-	jwt := authtypes.NewJWT(cmd.NewJWTSecret(ctx, logger), 30*time.Minute, 30*24*time.Hour)
-
 	signoz, err := signoz.New(
 		ctx,
 		config,
-		jwt,
 		zeus.Config{},
 		noopzeus.NewProviderFactory(),
 		licensing.Config{},
@@ -76,13 +73,16 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 		},
 		signoz.NewSQLStoreProviderFactories(),
 		signoz.NewTelemetryStoreProviderFactories(),
+		func(ctx context.Context, providerSettings factory.ProviderSettings, store authtypes.AuthNStore, licensing licensing.Licensing) (map[authtypes.AuthNProvider]authn.AuthN, error) {
+			return signoz.NewAuthNs(ctx, providerSettings, store, licensing)
+		},
 	)
 	if err != nil {
 		logger.ErrorContext(ctx, "failed to create signoz", "error", err)
 		return err
 	}
 
-	server, err := app.NewServer(config, signoz, jwt)
+	server, err := app.NewServer(config, signoz)
 	if err != nil {
 		logger.ErrorContext(ctx, "failed to create server", "error", err)
 		return err

cmd/config.go

@@ -3,7 +3,6 @@ package cmd
 import (
 	"context"
 	"log/slog"
-	"os"
 
 	"github.com/SigNoz/signoz/pkg/config"
 	"github.com/SigNoz/signoz/pkg/config/envprovider"
@@ -30,12 +29,3 @@ func NewSigNozConfig(ctx context.Context, logger *slog.Logger, flags signoz.Depr
 
 	return config, nil
 }
-
-func NewJWTSecret(ctx context.Context, logger *slog.Logger) string {
-	jwtSecret := os.Getenv("SIGNOZ_JWT_SECRET")
-	if len(jwtSecret) == 0 {
-		logger.ErrorContext(ctx, "🚨 CRITICAL SECURITY ISSUE: No JWT secret key specified!", "error", "SIGNOZ_JWT_SECRET environment variable is not set. This has dire consequences for the security of the application. Without a JWT secret, user sessions are vulnerable to tampering and unauthorized access. Please set the SIGNOZ_JWT_SECRET environment variable immediately. For more information, please refer to https://github.com/SigNoz/signoz/issues/8400.")
-	}
-
-	return jwtSecret
-}

cmd/enterprise/server.go

@@ -6,6 +6,8 @@ import (
 	"time"
 
 	"github.com/SigNoz/signoz/cmd"
+	"github.com/SigNoz/signoz/ee/authn/callbackauthn/oidccallbackauthn"
+	"github.com/SigNoz/signoz/ee/authn/callbackauthn/samlcallbackauthn"
 	enterpriselicensing "github.com/SigNoz/signoz/ee/licensing"
 	"github.com/SigNoz/signoz/ee/licensing/httplicensing"
 	enterpriseapp "github.com/SigNoz/signoz/ee/query-service/app"
@@ -14,6 +16,7 @@ import (
 	enterprisezeus "github.com/SigNoz/signoz/ee/zeus"
 	"github.com/SigNoz/signoz/ee/zeus/httpzeus"
 	"github.com/SigNoz/signoz/pkg/analytics"
+	"github.com/SigNoz/signoz/pkg/authn"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/licensing"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
@@ -54,17 +57,14 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 
 	// add enterprise sqlstore factories to the community sqlstore factories
 	sqlstoreFactories := signoz.NewSQLStoreProviderFactories()
-	if err := sqlstoreFactories.Add(postgressqlstore.NewFactory(sqlstorehook.NewLoggingFactory())); err != nil {
+	if err := sqlstoreFactories.Add(postgressqlstore.NewFactory(sqlstorehook.NewLoggingFactory(), sqlstorehook.NewInstrumentationFactory())); err != nil {
 		logger.ErrorContext(ctx, "failed to add postgressqlstore factory", "error", err)
 		return err
 	}
 
-	jwt := authtypes.NewJWT(cmd.NewJWTSecret(ctx, logger), 30*time.Minute, 30*24*time.Hour)
-
 	signoz, err := signoz.New(
 		ctx,
 		config,
-		jwt,
 		enterprisezeus.Config(),
 		httpzeus.NewProviderFactory(),
 		enterpriselicensing.Config(24*time.Hour, 3),
@@ -84,13 +84,34 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 		},
 		sqlstoreFactories,
 		signoz.NewTelemetryStoreProviderFactories(),
+		func(ctx context.Context, providerSettings factory.ProviderSettings, store authtypes.AuthNStore, licensing licensing.Licensing) (map[authtypes.AuthNProvider]authn.AuthN, error) {
+			samlCallbackAuthN, err := samlcallbackauthn.New(ctx, store, licensing)
+			if err != nil {
+				return nil, err
+			}
+
+			oidcCallbackAuthN, err := oidccallbackauthn.New(store, licensing, providerSettings)
+			if err != nil {
+				return nil, err
+			}
+
+			authNs, err := signoz.NewAuthNs(ctx, providerSettings, store, licensing)
+			if err != nil {
+				return nil, err
+			}
+
+			authNs[authtypes.AuthNProviderSAML] = samlCallbackAuthN
+			authNs[authtypes.AuthNProviderOIDC] = oidcCallbackAuthN
+
+			return authNs, nil
+		},
 	)
 	if err != nil {
 		logger.ErrorContext(ctx, "failed to create signoz", "error", err)
 		return err
 	}
 
-	server, err := enterpriseapp.NewServer(config, signoz, jwt)
+	server, err := enterpriseapp.NewServer(config, signoz)
 	if err != nil {
 		logger.ErrorContext(ctx, "failed to create server", "error", err)
 		return err

conf/example.yaml

@@ -243,3 +243,28 @@ statsreporter:
 gateway:
   # The URL of the gateway's api.
   url: http://localhost:8080
+
+##################### Tokenizer #####################
+tokenizer:
+  # Specifies the tokenizer provider to use.
+  provider: jwt
+  lifetime:
+    # The duration for which a user can be idle before being required to authenticate.
+    idle: 168h
+    # The duration for which a user can remain logged in before being asked to login.
+    max: 720h
+  rotation:
+    # The interval to rotate tokens in.
+    interval: 30m
+    # The duration for which the previous token pair remains valid after a token pair is rotated.
+    duration: 60s
+  jwt:
+    # The secret to sign the JWT tokens.
+    secret: secret
+  opaque:
+    gc:
+      # The interval to perform garbage collection.
+      interval: 1h
+    token:
+      # The maximum number of tokens a user can have. This limits the number of concurrent sessions a user can have.
+      max_per_user: 5

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

@@ -176,7 +176,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.96.1
+    image: signoz/signoz:v0.97.0
     command:
       - --config=/root/config/prometheus.yml
     ports:
@@ -209,7 +209,7 @@ services:
       retries: 3
   otel-collector:
     !!merge <<: *db-depend
-    image: signoz/signoz-otel-collector:v0.129.6
+    image: signoz/signoz-otel-collector:v0.129.7
     command:
       - --config=/etc/otel-collector-config.yaml
       - --manager-config=/etc/manager-config.yaml
@@ -233,7 +233,7 @@ services:
       - signoz
   schema-migrator:
     !!merge <<: *common
-    image: signoz/signoz-schema-migrator:v0.129.6
+    image: signoz/signoz-schema-migrator:v0.129.7
     deploy:
       restart_policy:
         condition: on-failure

deploy/docker-swarm/docker-compose.yaml

@@ -117,7 +117,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.96.1
+    image: signoz/signoz:v0.97.0
     command:
       - --config=/root/config/prometheus.yml
     ports:
@@ -150,7 +150,7 @@ services:
       retries: 3
   otel-collector:
     !!merge <<: *db-depend
-    image: signoz/signoz-otel-collector:v0.129.6
+    image: signoz/signoz-otel-collector:v0.129.7
     command:
       - --config=/etc/otel-collector-config.yaml
       - --manager-config=/etc/manager-config.yaml
@@ -176,7 +176,7 @@ services:
       - signoz
   schema-migrator:
     !!merge <<: *common
-    image: signoz/signoz-schema-migrator:v0.129.6
+    image: signoz/signoz-schema-migrator:v0.129.7
     deploy:
       restart_policy:
         condition: on-failure

deploy/docker/docker-compose.ha.yaml

@@ -179,7 +179,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.96.1}
+    image: signoz/signoz:${VERSION:-v0.97.0}
     container_name: signoz
     command:
       - --config=/root/config/prometheus.yml
@@ -213,7 +213,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.129.6}
+    image: signoz/signoz-otel-collector:${OTELCOL_TAG:-v0.129.7}
     container_name: signoz-otel-collector
     command:
       - --config=/etc/otel-collector-config.yaml
@@ -239,7 +239,7 @@ services:
         condition: service_healthy
   schema-migrator-sync:
     !!merge <<: *common
-    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.129.6}
+    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.129.7}
     container_name: schema-migrator-sync
     command:
       - sync
@@ -250,7 +250,7 @@ services:
         condition: service_healthy
   schema-migrator-async:
     !!merge <<: *db-depend
-    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.129.6}
+    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.129.7}
     container_name: schema-migrator-async
     command:
       - async

deploy/docker/docker-compose.yaml

@@ -111,7 +111,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.96.1}
+    image: signoz/signoz:${VERSION:-v0.97.0}
     container_name: signoz
     command:
       - --config=/root/config/prometheus.yml
@@ -144,7 +144,7 @@ services:
       retries: 3
   otel-collector:
     !!merge <<: *db-depend
-    image: signoz/signoz-otel-collector:${OTELCOL_TAG:-v0.129.6}
+    image: signoz/signoz-otel-collector:${OTELCOL_TAG:-v0.129.7}
     container_name: signoz-otel-collector
     command:
       - --config=/etc/otel-collector-config.yaml
@@ -166,7 +166,7 @@ services:
         condition: service_healthy
   schema-migrator-sync:
     !!merge <<: *common
-    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.129.6}
+    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.129.7}
     container_name: schema-migrator-sync
     command:
       - sync
@@ -178,7 +178,7 @@ services:
     restart: on-failure
   schema-migrator-async:
     !!merge <<: *db-depend
-    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.129.6}
+    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.129.7}
     container_name: schema-migrator-async
     command:
       - async

ee/anomaly/seasonal.go

@@ -232,7 +232,7 @@ func (p *BaseSeasonalProvider) getPredictedSeries(
 // moving avg of the previous period series + z score threshold * std dev of the series
 // moving avg of the previous period series - z score threshold * std dev of the series
 func (p *BaseSeasonalProvider) getBounds(
-	series, predictedSeries *qbtypes.TimeSeries,
+	series, predictedSeries, weekSeries *qbtypes.TimeSeries,
 	zScoreThreshold float64,
 ) (*qbtypes.TimeSeries, *qbtypes.TimeSeries) {
 	upperBoundSeries := &qbtypes.TimeSeries{
@@ -246,8 +246,8 @@ func (p *BaseSeasonalProvider) getBounds(
 	}
 
 	for idx, curr := range series.Values {
-		upperBound := p.getMovingAvg(predictedSeries, movingAvgWindowSize, idx) + zScoreThreshold*p.getStdDev(series)
-		lowerBound := p.getMovingAvg(predictedSeries, movingAvgWindowSize, idx) - zScoreThreshold*p.getStdDev(series)
+		upperBound := p.getMovingAvg(predictedSeries, movingAvgWindowSize, idx) + zScoreThreshold*p.getStdDev(weekSeries)
+		lowerBound := p.getMovingAvg(predictedSeries, movingAvgWindowSize, idx) - zScoreThreshold*p.getStdDev(weekSeries)
 		upperBoundSeries.Values = append(upperBoundSeries.Values, &qbtypes.TimeSeriesValue{
 			Timestamp: curr.Timestamp,
 			Value:     upperBound,
@@ -398,8 +398,6 @@ func (p *BaseSeasonalProvider) getAnomalies(ctx context.Context, orgID valuer.UU
 		aggOfInterest := result.Aggregations[0]
 
 		for _, series := range aggOfInterest.Series {
-			stdDev := p.getStdDev(series)
-			p.logger.InfoContext(ctx, "calculated standard deviation for series", "anomaly_std_dev", stdDev, "anomaly_labels", series.Labels)
 
 			pastPeriodSeries := p.getMatchingSeries(ctx, pastPeriodResult, series)
 			currentSeasonSeries := p.getMatchingSeries(ctx, currentSeasonResult, series)
@@ -407,6 +405,9 @@ func (p *BaseSeasonalProvider) getAnomalies(ctx context.Context, orgID valuer.UU
 			past2SeasonSeries := p.getMatchingSeries(ctx, past2SeasonResult, series)
 			past3SeasonSeries := p.getMatchingSeries(ctx, past3SeasonResult, series)
 
+			stdDev := p.getStdDev(currentSeasonSeries)
+			p.logger.InfoContext(ctx, "calculated standard deviation for series", "anomaly_std_dev", stdDev, "anomaly_labels", series.Labels)
+
 			prevSeriesAvg := p.getAvg(pastPeriodSeries)
 			currentSeasonSeriesAvg := p.getAvg(currentSeasonSeries)
 			pastSeasonSeriesAvg := p.getAvg(pastSeasonSeries)
@@ -435,6 +436,7 @@ func (p *BaseSeasonalProvider) getAnomalies(ctx context.Context, orgID valuer.UU
 			upperBoundSeries, lowerBoundSeries := p.getBounds(
 				series,
 				predictedSeries,
+				currentSeasonSeries,
 				zScoreThreshold,
 			)
 			aggOfInterest.UpperBoundSeries = append(aggOfInterest.UpperBoundSeries, upperBoundSeries)

ee/authn/callbackauthn/oidccallbackauthn/authn.go

@@ -0,0 +1,191 @@
+package oidccallbackauthn
+
+import (
+	"context"
+	"net/url"
+
+	"github.com/SigNoz/signoz/pkg/authn"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/http/client"
+	"github.com/SigNoz/signoz/pkg/licensing"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/coreos/go-oidc/v3/oidc"
+	"golang.org/x/oauth2"
+)
+
+const (
+	redirectPath string = "/api/v1/complete/oidc"
+)
+
+var (
+	scopes []string = []string{"email", oidc.ScopeOpenID}
+)
+
+var _ authn.CallbackAuthN = (*AuthN)(nil)
+
+type AuthN struct {
+	store      authtypes.AuthNStore
+	licensing  licensing.Licensing
+	httpClient *client.Client
+}
+
+func New(store authtypes.AuthNStore, licensing licensing.Licensing, providerSettings factory.ProviderSettings) (*AuthN, error) {
+	httpClient, err := client.New(providerSettings.Logger, providerSettings.TracerProvider, providerSettings.MeterProvider)
+	if err != nil {
+		return nil, err
+	}
+
+	return &AuthN{
+		store:      store,
+		licensing:  licensing,
+		httpClient: httpClient,
+	}, nil
+}
+
+func (a *AuthN) LoginURL(ctx context.Context, siteURL *url.URL, authDomain *authtypes.AuthDomain) (string, error) {
+	if authDomain.AuthDomainConfig().AuthNProvider != authtypes.AuthNProviderOIDC {
+		return "", errors.Newf(errors.TypeInternal, authtypes.ErrCodeAuthDomainMismatch, "domain type is not oidc")
+	}
+
+	_, oauth2Config, err := a.oidcProviderAndoauth2Config(ctx, siteURL, authDomain)
+	if err != nil {
+		return "", err
+	}
+
+	return oauth2Config.AuthCodeURL(authtypes.NewState(siteURL, authDomain.StorableAuthDomain().ID).URL.String()), nil
+}
+
+func (a *AuthN) HandleCallback(ctx context.Context, query url.Values) (*authtypes.CallbackIdentity, error) {
+	if err := query.Get("error"); err != "" {
+		return nil, errors.Newf(errors.TypeInternal, errors.CodeInternal, "oidc: error while authenticating").WithAdditional(query.Get("error_description"))
+	}
+
+	state, err := authtypes.NewStateFromString(query.Get("state"))
+	if err != nil {
+		return nil, errors.Newf(errors.TypeInvalidInput, authtypes.ErrCodeInvalidState, "oidc: invalid state").WithAdditional(err.Error())
+	}
+
+	authDomain, err := a.store.GetAuthDomainFromID(ctx, state.DomainID)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = a.licensing.GetActive(ctx, authDomain.StorableAuthDomain().OrgID)
+	if err != nil {
+		return nil, errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	oidcProvider, oauth2Config, err := a.oidcProviderAndoauth2Config(ctx, state.URL, authDomain)
+	if err != nil {
+		return nil, err
+	}
+
+	ctx = context.WithValue(ctx, oauth2.HTTPClient, a.httpClient.Client())
+	token, err := oauth2Config.Exchange(ctx, query.Get("code"))
+	if err != nil {
+		var retrieveError *oauth2.RetrieveError
+		if errors.As(err, &retrieveError) {
+			return nil, errors.Newf(errors.TypeForbidden, errors.CodeForbidden, "oidc: failed to get token").WithAdditional(retrieveError.ErrorDescription).WithAdditional(string(retrieveError.Body))
+		}
+
+		return nil, errors.Newf(errors.TypeInternal, errors.CodeInternal, "oidc: failed to get token").WithAdditional(err.Error())
+	}
+
+	claims, err := a.claimsFromIDToken(ctx, authDomain, oidcProvider, token)
+	if err != nil && !errors.Ast(err, errors.TypeNotFound) {
+		return nil, err
+	}
+
+	if claims == nil && authDomain.AuthDomainConfig().OIDC.GetUserInfo {
+		claims, err = a.claimsFromUserInfo(ctx, oidcProvider, token)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	emailClaim, ok := claims[authDomain.AuthDomainConfig().OIDC.ClaimMapping.Email].(string)
+	if !ok {
+		return nil, errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "oidc: missing email in claims")
+	}
+
+	email, err := valuer.NewEmail(emailClaim)
+	if err != nil {
+		return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "oidc: failed to parse email").WithAdditional(err.Error())
+	}
+
+	if !authDomain.AuthDomainConfig().OIDC.InsecureSkipEmailVerified {
+		emailVerifiedClaim, ok := claims["email_verified"].(bool)
+		if !ok {
+			return nil, errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "oidc: missing email_verified in claims")
+		}
+
+		if !emailVerifiedClaim {
+			return nil, errors.New(errors.TypeForbidden, errors.CodeForbidden, "oidc: email is not verified")
+		}
+	}
+
+	return authtypes.NewCallbackIdentity("", email, authDomain.StorableAuthDomain().OrgID, state), nil
+}
+
+func (a *AuthN) oidcProviderAndoauth2Config(ctx context.Context, siteURL *url.URL, authDomain *authtypes.AuthDomain) (*oidc.Provider, *oauth2.Config, error) {
+	if authDomain.AuthDomainConfig().OIDC.IssuerAlias != "" {
+		ctx = oidc.InsecureIssuerURLContext(ctx, authDomain.AuthDomainConfig().OIDC.IssuerAlias)
+	}
+
+	oidcProvider, err := oidc.NewProvider(ctx, authDomain.AuthDomainConfig().OIDC.Issuer)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return oidcProvider, &oauth2.Config{
+		ClientID:     authDomain.AuthDomainConfig().OIDC.ClientID,
+		ClientSecret: authDomain.AuthDomainConfig().OIDC.ClientSecret,
+		Endpoint:     oidcProvider.Endpoint(),
+		Scopes:       scopes,
+		RedirectURL: (&url.URL{
+			Scheme: siteURL.Scheme,
+			Host:   siteURL.Host,
+			Path:   redirectPath,
+		}).String(),
+	}, nil
+}
+
+func (a *AuthN) claimsFromIDToken(ctx context.Context, authDomain *authtypes.AuthDomain, provider *oidc.Provider, token *oauth2.Token) (map[string]any, error) {
+	rawIDToken, ok := token.Extra("id_token").(string)
+	if !ok {
+		return nil, errors.New(errors.TypeNotFound, errors.CodeNotFound, "oidc: no id_token in token response")
+	}
+
+	verifier := provider.Verifier(&oidc.Config{ClientID: authDomain.AuthDomainConfig().OIDC.ClientID})
+	idToken, err := verifier.Verify(ctx, rawIDToken)
+	if err != nil {
+		return nil, errors.Newf(errors.TypeForbidden, errors.CodeForbidden, "oidc: failed to verify token").WithAdditional(err.Error())
+	}
+
+	var claims map[string]any
+	if err := idToken.Claims(&claims); err != nil {
+		return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "oidc: failed to decode claims").WithAdditional(err.Error())
+	}
+
+	return claims, nil
+}
+
+func (a *AuthN) claimsFromUserInfo(ctx context.Context, provider *oidc.Provider, token *oauth2.Token) (map[string]any, error) {
+	var claims map[string]any
+
+	userInfo, err := provider.UserInfo(ctx, oauth2.StaticTokenSource(&oauth2.Token{
+		AccessToken: token.AccessToken,
+		TokenType:   "Bearer", // The UserInfo endpoint requires a bearer token as per RFC6750
+	}))
+	if err != nil {
+		return nil, errors.Newf(errors.TypeInternal, errors.CodeInternal, "oidc: failed to get user info").WithAdditional(err.Error())
+	}
+
+	if err := userInfo.Claims(&claims); err != nil {
+		return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "oidc: failed to decode claims").WithAdditional(err.Error())
+	}
+
+	return claims, nil
+}

ee/authn/callbackauthn/samlcallbackauthn/authn.go

@@ -0,0 +1,155 @@
+package samlcallbackauthn
+
+import (
+	"context"
+	"crypto/x509"
+	"encoding/base64"
+	"encoding/pem"
+	"net/url"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/authn"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/licensing"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	saml2 "github.com/russellhaering/gosaml2"
+	dsig "github.com/russellhaering/goxmldsig"
+)
+
+const (
+	redirectPath string = "/api/v1/complete/saml"
+)
+
+var _ authn.CallbackAuthN = (*AuthN)(nil)
+
+type AuthN struct {
+	store     authtypes.AuthNStore
+	licensing licensing.Licensing
+}
+
+func New(ctx context.Context, store authtypes.AuthNStore, licensing licensing.Licensing) (*AuthN, error) {
+	return &AuthN{
+		store:     store,
+		licensing: licensing,
+	}, nil
+}
+
+func (a *AuthN) LoginURL(ctx context.Context, siteURL *url.URL, authDomain *authtypes.AuthDomain) (string, error) {
+	if authDomain.AuthDomainConfig().AuthNProvider != authtypes.AuthNProviderSAML {
+		return "", errors.Newf(errors.TypeInternal, authtypes.ErrCodeAuthDomainMismatch, "saml: domain type is not saml")
+	}
+
+	sp, err := a.serviceProvider(siteURL, authDomain)
+	if err != nil {
+		return "", err
+	}
+
+	url, err := sp.BuildAuthURL(authtypes.NewState(siteURL, authDomain.StorableAuthDomain().ID).URL.String())
+	if err != nil {
+		return "", err
+	}
+
+	return url, nil
+}
+
+func (a *AuthN) HandleCallback(ctx context.Context, formValues url.Values) (*authtypes.CallbackIdentity, error) {
+	state, err := authtypes.NewStateFromString(formValues.Get("RelayState"))
+	if err != nil {
+		return nil, errors.New(errors.TypeInvalidInput, authtypes.ErrCodeInvalidState, "saml: invalid state").WithAdditional(err.Error())
+	}
+
+	authDomain, err := a.store.GetAuthDomainFromID(ctx, state.DomainID)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = a.licensing.GetActive(ctx, authDomain.StorableAuthDomain().OrgID)
+	if err != nil {
+		return nil, errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	sp, err := a.serviceProvider(state.URL, authDomain)
+	if err != nil {
+		return nil, err
+	}
+
+	assertionInfo, err := sp.RetrieveAssertionInfo(formValues.Get("SAMLResponse"))
+	if err != nil {
+		if errors.As(err, &saml2.ErrVerification{}) {
+			return nil, errors.New(errors.TypeForbidden, errors.CodeForbidden, err.Error())
+		}
+
+		if errors.As(err, &saml2.ErrMissingElement{}) {
+			return nil, errors.New(errors.TypeNotFound, errors.CodeNotFound, err.Error())
+		}
+
+		return nil, err
+	}
+
+	if assertionInfo.WarningInfo.InvalidTime {
+		return nil, errors.New(errors.TypeForbidden, errors.CodeForbidden, "saml: expired saml response")
+	}
+
+	email, err := valuer.NewEmail(assertionInfo.NameID)
+	if err != nil {
+		return nil, errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "saml: invalid email").WithAdditional("The nameID assertion is used to retrieve the email address, please check your IDP configuration and try again.")
+	}
+
+	return authtypes.NewCallbackIdentity("", email, authDomain.StorableAuthDomain().OrgID, state), nil
+}
+
+func (a *AuthN) serviceProvider(siteURL *url.URL, authDomain *authtypes.AuthDomain) (*saml2.SAMLServiceProvider, error) {
+	certStore, err := a.getCertificateStore(authDomain)
+	if err != nil {
+		return nil, err
+	}
+
+	acsURL := &url.URL{Scheme: siteURL.Scheme, Host: siteURL.Host, Path: redirectPath}
+
+	// Note:
+	// The ServiceProviderIssuer is the client id in case of keycloak. Since we set it to the host here, we need to set the client id == host in keycloak.
+	// For AWSSSO, this is the value of Application SAML audience.
+	return &saml2.SAMLServiceProvider{
+		IdentityProviderSSOURL:      authDomain.AuthDomainConfig().SAML.SamlIdp,
+		IdentityProviderIssuer:      authDomain.AuthDomainConfig().SAML.SamlEntity,
+		ServiceProviderIssuer:       siteURL.Host,
+		AssertionConsumerServiceURL: acsURL.String(),
+		SignAuthnRequests:           !authDomain.AuthDomainConfig().SAML.InsecureSkipAuthNRequestsSigned,
+		AllowMissingAttributes:      true,
+		IDPCertificateStore:         certStore,
+		SPKeyStore:                  dsig.RandomKeyStoreForTest(),
+	}, nil
+}
+
+func (a *AuthN) getCertificateStore(authDomain *authtypes.AuthDomain) (dsig.X509CertificateStore, error) {
+	certStore := &dsig.MemoryX509CertificateStore{
+		Roots: []*x509.Certificate{},
+	}
+
+	var certBytes []byte
+	if strings.Contains(authDomain.AuthDomainConfig().SAML.SamlCert, "-----BEGIN CERTIFICATE-----") {
+		block, _ := pem.Decode([]byte(authDomain.AuthDomainConfig().SAML.SamlCert))
+		if block == nil {
+			return certStore, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "no valid pem cert found")
+		}
+
+		certBytes = block.Bytes
+	} else {
+		certData, err := base64.StdEncoding.DecodeString(authDomain.AuthDomainConfig().SAML.SamlCert)
+		if err != nil {
+			return certStore, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to read certificate: %s", err.Error())
+		}
+
+		certBytes = certData
+	}
+
+	idpCert, err := x509.ParseCertificate(certBytes)
+	if err != nil {
+		return certStore, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to prepare saml request, invalid cert: %s", err.Error())
+	}
+
+	certStore.Roots = append(certStore.Roots, idpCert)
+
+	return certStore, nil
+}

ee/authz/openfgaauthz/provider.go

@@ -0,0 +1,79 @@
+package openfgaauthz
+
+import (
+	"context"
+
+	"github.com/SigNoz/signoz/pkg/authz"
+	pkgopenfgaauthz "github.com/SigNoz/signoz/pkg/authz/openfgaauthz"
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	openfgav1 "github.com/openfga/api/proto/openfga/v1"
+	openfgapkgtransformer "github.com/openfga/language/pkg/go/transformer"
+)
+
+type provider struct {
+	pkgAuthzService authz.AuthZ
+}
+
+func NewProviderFactory(sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile) factory.ProviderFactory[authz.AuthZ, authz.Config] {
+	return factory.NewProviderFactory(factory.MustNewName("openfga"), func(ctx context.Context, ps factory.ProviderSettings, config authz.Config) (authz.AuthZ, error) {
+		return newOpenfgaProvider(ctx, ps, config, sqlstore, openfgaSchema)
+	})
+}
+
+func newOpenfgaProvider(ctx context.Context, settings factory.ProviderSettings, config authz.Config, sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile) (authz.AuthZ, error) {
+	pkgOpenfgaAuthzProvider := pkgopenfgaauthz.NewProviderFactory(sqlstore, openfgaSchema)
+	pkgAuthzService, err := pkgOpenfgaAuthzProvider.New(ctx, settings, config)
+	if err != nil {
+		return nil, err
+	}
+
+	return &provider{
+		pkgAuthzService: pkgAuthzService,
+	}, nil
+}
+
+func (provider *provider) Start(ctx context.Context) error {
+	return provider.pkgAuthzService.Start(ctx)
+}
+
+func (provider *provider) Stop(ctx context.Context) error {
+	return provider.pkgAuthzService.Stop(ctx)
+}
+
+func (provider *provider) Check(ctx context.Context, tuple *openfgav1.TupleKey) error {
+	return provider.pkgAuthzService.Check(ctx, tuple)
+}
+
+func (provider *provider) CheckWithTupleCreation(ctx context.Context, claims authtypes.Claims, orgID valuer.UUID, relation authtypes.Relation, _ authtypes.Relation, typeable authtypes.Typeable, selectors []authtypes.Selector) error {
+	subject, err := authtypes.NewSubject(authtypes.TypeUser, claims.UserID, authtypes.Relation{})
+	if err != nil {
+		return err
+	}
+
+	tuples, err := typeable.Tuples(subject, relation, selectors, orgID)
+	if err != nil {
+		return err
+	}
+
+	err = provider.BatchCheck(ctx, tuples)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (provider *provider) BatchCheck(ctx context.Context, tuples []*openfgav1.TupleKey) error {
+	return provider.pkgAuthzService.BatchCheck(ctx, tuples)
+}
+
+func (provider *provider) ListObjects(ctx context.Context, subject string, relation authtypes.Relation, typeable authtypes.Typeable) ([]*authtypes.Object, error) {
+	return provider.pkgAuthzService.ListObjects(ctx, subject, relation, typeable)
+}
+
+func (provider *provider) Write(ctx context.Context, additions []*openfgav1.TupleKey, deletions []*openfgav1.TupleKey) error {
+	return provider.pkgAuthzService.Write(ctx, additions, deletions)
+}

ee/http/middleware/authz.go

@@ -1,132 +0,0 @@
-package middleware
-
-import (
-	"log/slog"
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/authz"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/gorilla/mux"
-)
-
-const (
-	authzDeniedMessage string = "::AUTHZ-DENIED::"
-)
-
-type AuthZ struct {
-	logger       *slog.Logger
-	authzService authz.AuthZ
-}
-
-func NewAuthZ(logger *slog.Logger) *AuthZ {
-	if logger == nil {
-		panic("cannot build authz middleware, logger is empty")
-	}
-
-	return &AuthZ{logger: logger}
-}
-
-func (middleware *AuthZ) ViewAccess(next http.HandlerFunc) http.HandlerFunc {
-	return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
-		claims, err := authtypes.ClaimsFromContext(req.Context())
-		if err != nil {
-			render.Error(rw, err)
-			return
-		}
-
-		if err := claims.IsViewer(); err != nil {
-			middleware.logger.WarnContext(req.Context(), authzDeniedMessage, "claims", claims)
-			render.Error(rw, err)
-			return
-		}
-
-		next(rw, req)
-	})
-}
-
-func (middleware *AuthZ) EditAccess(next http.HandlerFunc) http.HandlerFunc {
-	return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
-		claims, err := authtypes.ClaimsFromContext(req.Context())
-		if err != nil {
-			render.Error(rw, err)
-			return
-		}
-
-		if err := claims.IsEditor(); err != nil {
-			middleware.logger.WarnContext(req.Context(), authzDeniedMessage, "claims", claims)
-			render.Error(rw, err)
-			return
-		}
-
-		next(rw, req)
-	})
-}
-
-func (middleware *AuthZ) AdminAccess(next http.HandlerFunc) http.HandlerFunc {
-	return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
-		claims, err := authtypes.ClaimsFromContext(req.Context())
-		if err != nil {
-			render.Error(rw, err)
-			return
-		}
-
-		if err := claims.IsAdmin(); err != nil {
-			middleware.logger.WarnContext(req.Context(), authzDeniedMessage, "claims", claims)
-			render.Error(rw, err)
-			return
-		}
-
-		next(rw, req)
-	})
-}
-
-func (middleware *AuthZ) SelfAccess(next http.HandlerFunc) http.HandlerFunc {
-	return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
-		claims, err := authtypes.ClaimsFromContext(req.Context())
-		if err != nil {
-			render.Error(rw, err)
-			return
-		}
-
-		id := mux.Vars(req)["id"]
-		if err := claims.IsSelfAccess(id); err != nil {
-			middleware.logger.WarnContext(req.Context(), authzDeniedMessage, "claims", claims)
-			render.Error(rw, err)
-			return
-		}
-
-		next(rw, req)
-	})
-}
-
-func (middleware *AuthZ) OpenAccess(next http.HandlerFunc) http.HandlerFunc {
-	return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
-		next(rw, req)
-	})
-}
-
-// Check middleware accepts the relation, typeable, parentTypeable (for direct access + group relations) and a callback function to derive selector and parentSelectors on per request basis.
-func (middleware *AuthZ) Check(next http.HandlerFunc, relation authtypes.Relation, translation authtypes.Relation, typeable authtypes.Typeable, cb authtypes.SelectorCallbackFn) http.HandlerFunc {
-	return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
-		claims, err := authtypes.ClaimsFromContext(req.Context())
-		if err != nil {
-			render.Error(rw, err)
-			return
-		}
-
-		selector, err := cb(req.Context(), claims)
-		if err != nil {
-			render.Error(rw, err)
-			return
-		}
-
-		err = middleware.authzService.CheckWithTupleCreation(req.Context(), claims, relation, typeable, selector)
-		if err != nil {
-			render.Error(rw, err)
-			return
-		}
-
-		next(rw, req)
-	})
-}

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

@@ -20,7 +20,6 @@ import (
 	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/authtypes"
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/gorilla/mux"
 )
@@ -35,10 +34,7 @@ type APIHandlerOptions struct {
 	Gateway                       *httputil.ReverseProxy
 	GatewayUrl                    string
 	// Querier Influx Interval
-	FluxInterval      time.Duration
-	UseLogsNewSchema  bool
-	UseTraceNewSchema bool
-	JWT               *authtypes.JWT
+	FluxInterval time.Duration
 }
 
 type APIHandler struct {
@@ -93,7 +89,8 @@ func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	router.HandleFunc("/api/v1/features", am.ViewAccess(ah.getFeatureFlags)).Methods(http.MethodGet)
 
 	// paid plans specific routes
-	router.HandleFunc("/api/v1/complete/saml", am.OpenAccess(ah.receiveSAML)).Methods(http.MethodPost)
+	router.HandleFunc("/api/v1/complete/saml", am.OpenAccess(ah.Signoz.Handlers.Session.CreateSessionBySAMLCallback)).Methods(http.MethodPost)
+	router.HandleFunc("/api/v1/complete/oidc", am.OpenAccess(ah.Signoz.Handlers.Session.CreateSessionByOIDCCallback)).Methods(http.MethodGet)
 
 	// base overrides
 	router.HandleFunc("/api/v1/version", am.OpenAccess(ah.getVersion)).Methods(http.MethodGet)

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

@@ -1,107 +0,0 @@
-package api
-
-import (
-	"context"
-	"encoding/base64"
-	"fmt"
-	"net/http"
-	"net/url"
-
-	"go.uber.org/zap"
-
-	"github.com/SigNoz/signoz/pkg/query-service/constants"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-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)))
-	base64.StdEncoding.Encode(dst, ssoError)
-
-	http.Redirect(w, r, fmt.Sprintf("%s?ssoerror=%s", redirectURL, string(dst)), 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()
-
-	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))
-		handleSsoError(w, r, redirectUri)
-		return
-	}
-
-	// the relay state is sent when a login request is submitted to
-	// Idp.
-	relayState := r.FormValue("RelayState")
-	zap.L().Debug("[receiveML] relay state", zap.String("relayState", relayState))
-
-	parsedState, err := url.Parse(relayState)
-	if err != nil || relayState == "" {
-		zap.L().Error("[receiveSAML] 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.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))
-		handleSsoError(w, r, redirectUri)
-		return
-	}
-
-	assertionInfo, err := sp.RetrieveAssertionInfo(r.FormValue("SAMLResponse"))
-	if err != nil {
-		zap.L().Error("[receiveSAML] failed to retrieve assertion info from  saml response", zap.String("domain", domain.String()), zap.Error(err))
-		handleSsoError(w, r, redirectUri)
-		return
-	}
-
-	if assertionInfo.WarningInfo.InvalidTime {
-		zap.L().Error("[receiveSAML] expired saml response", zap.String("domain", domain.String()), zap.Error(err))
-		handleSsoError(w, r, redirectUri)
-		return
-	}
-
-	email := assertionInfo.NameID
-	if email == "" {
-		zap.L().Error("[receiveSAML] invalid email in the SSO response", zap.String("domain", domain.String()))
-		handleSsoError(w, r, redirectUri)
-		return
-	}
-
-	nextPage, err := ah.Signoz.Modules.User.PrepareSsoRedirect(ctx, redirectUri, email)
-	if err != nil {
-		zap.L().Error("[receiveSAML] 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)
-}

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

@@ -168,38 +168,22 @@ func (ah *APIHandler) getOrCreateCloudIntegrationPAT(ctx context.Context, orgId
 func (ah *APIHandler) getOrCreateCloudIntegrationUser(
 	ctx context.Context, orgId string, cloudProvider string,
 ) (*types.User, *basemodel.ApiError) {
-	cloudIntegrationUser := fmt.Sprintf("%s-integration", cloudProvider)
-	email := fmt.Sprintf("%s@signoz.io", cloudIntegrationUser)
+	cloudIntegrationUserName := fmt.Sprintf("%s-integration", cloudProvider)
+	email := valuer.MustNewEmail(fmt.Sprintf("%s@signoz.io", cloudIntegrationUserName))
 
-	integrationUserResult, err := ah.Signoz.Modules.User.GetUserByEmailInOrg(ctx, orgId, email)
-	if err != nil && !errors.Ast(err, errors.TypeNotFound) {
-		return nil, basemodel.NotFoundError(fmt.Errorf("couldn't look for integration user: %w", err))
-	}
-
-	if integrationUserResult != nil {
-		return &integrationUserResult.User, nil
-	}
-
-	zap.L().Info(
-		"cloud integration user not found. Attempting to create the user",
-		zap.String("cloudProvider", cloudProvider),
-	)
-
-	newUser, err := types.NewUser(cloudIntegrationUser, email, types.RoleViewer.String(), orgId)
-	if err != nil {
-		return nil, basemodel.InternalError(fmt.Errorf(
-			"couldn't create cloud integration user: %w", err,
-		))
-	}
-
-	password := types.MustGenerateFactorPassword(newUser.ID.StringValue())
-
-	err = ah.Signoz.Modules.User.CreateUser(ctx, newUser, user.WithFactorPassword(password))
+	cloudIntegrationUser, err := types.NewUser(cloudIntegrationUserName, email, types.RoleViewer, valuer.MustNewUUID(orgId))
 	if err != nil {
 		return nil, basemodel.InternalError(fmt.Errorf("couldn't create cloud integration user: %w", err))
 	}
 
-	return newUser, nil
+	password := types.MustGenerateFactorPassword(cloudIntegrationUser.ID.StringValue())
+
+	cloudIntegrationUser, err = ah.Signoz.Modules.User.GetOrCreateUser(ctx, cloudIntegrationUser, user.WithFactorPassword(password))
+	if err != nil {
+		return nil, basemodel.InternalError(fmt.Errorf("couldn't look for integration user: %w", err))
+	}
+
+	return cloudIntegrationUser, nil
 }
 
 func getIngestionUrlAndSigNozAPIUrl(ctx context.Context, licenseKey string) (

ee/query-service/app/server.go

@@ -7,8 +7,11 @@ import (
 	"net"
 	"net/http"
 	_ "net/http/pprof" // http profiler
+	"slices"
 
 	"github.com/SigNoz/signoz/pkg/ruler/rulestore/sqlrulestore"
+	"go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux"
+	"go.opentelemetry.io/otel/propagation"
 
 	"github.com/gorilla/handlers"
 
@@ -25,7 +28,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/signoz"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/web"
 	"github.com/rs/cors"
 	"github.com/soheilhy/cmux"
@@ -50,7 +52,6 @@ import (
 type Server struct {
 	config      signoz.Config
 	signoz      *signoz.SigNoz
-	jwt         *authtypes.JWT
 	ruleManager *baserules.Manager
 
 	// public http router
@@ -67,7 +68,7 @@ type Server struct {
 }
 
 // NewServer creates and initializes Server
-func NewServer(config signoz.Config, signoz *signoz.SigNoz, jwt *authtypes.JWT) (*Server, error) {
+func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 	gatewayProxy, err := gateway.NewProxy(config.Gateway.URL.String(), gateway.RoutePrefix)
 	if err != nil {
 		return nil, err
@@ -153,7 +154,6 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz, jwt *authtypes.JWT)
 		FluxInterval:                  config.Querier.FluxInterval,
 		Gateway:                       gatewayProxy,
 		GatewayUrl:                    config.Gateway.URL.String(),
-		JWT:                           jwt,
 	}
 
 	apiHandler, err := api.NewAPIHandler(apiOpts, signoz)
@@ -164,7 +164,6 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz, jwt *authtypes.JWT)
 	s := &Server{
 		config:             config,
 		signoz:             signoz,
-		jwt:                jwt,
 		ruleManager:        rm,
 		httpHostPort:       baseconst.HTTPHostPort,
 		unavailableChannel: make(chan healthcheck.Status),
@@ -195,7 +194,17 @@ func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*h
 	r := baseapp.NewRouter()
 	am := middleware.NewAuthZ(s.signoz.Instrumentation.Logger())
 
-	r.Use(middleware.NewAuth(s.jwt, []string{"Authorization", "Sec-WebSocket-Protocol"}, s.signoz.Sharder, s.signoz.Instrumentation.Logger()).Wrap)
+	r.Use(otelmux.Middleware(
+		"apiserver",
+		otelmux.WithMeterProvider(s.signoz.Instrumentation.MeterProvider()),
+		otelmux.WithTracerProvider(s.signoz.Instrumentation.TracerProvider()),
+		otelmux.WithPropagators(propagation.NewCompositeTextMapPropagator(propagation.Baggage{}, propagation.TraceContext{})),
+		otelmux.WithFilter(func(r *http.Request) bool {
+			return !slices.Contains([]string{"/api/v1/health"}, r.URL.Path)
+		}),
+		otelmux.WithPublicEndpoint(),
+	))
+	r.Use(middleware.NewAuthN([]string{"Authorization", "Sec-WebSocket-Protocol"}, s.signoz.Sharder, s.signoz.Tokenizer, s.signoz.Instrumentation.Logger()).Wrap)
 	r.Use(middleware.NewAPIKey(s.signoz.SQLStore, []string{"SIGNOZ-API-KEY"}, s.signoz.Instrumentation.Logger(), s.signoz.Sharder).Wrap)
 	r.Use(middleware.NewTimeout(s.signoz.Instrumentation.Logger(),
 		s.config.APIServer.Timeout.ExcludedRoutes,

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", "")
@@ -27,13 +23,6 @@ func GetOrDefaultEnv(key string, fallback string) string {
 
 // 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)
-}
-
 const DotMetricsEnabled = "DOT_METRICS_ENABLED"
 
 var IsDotMetricsEnabled = false

ee/query-service/rules/anomaly.go

@@ -78,11 +78,6 @@ func NewAnomalyRule(
 
 	opts = append(opts, baserules.WithLogger(logger))
 
-	if p.RuleCondition.CompareOp == ruletypes.ValueIsBelow {
-		target := -1 * *p.RuleCondition.Target
-		p.RuleCondition.Target = &target
-	}
-
 	baseRule, err := baserules.NewBaseRule(id, orgID, p, reader, opts...)
 	if err != nil {
 		return nil, err

frontend/public/Logos/anthropic-api-monitoring.svg

@@ -0,0 +1,16 @@
+<svg version="1.1" id="Layer_1" xmlns:x="ns_extend;" xmlns:i="ns_ai;" xmlns:graph="ns_graphs;" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 92.2 65" style="enable-background:new 0 0 92.2 65;" xml:space="preserve">
+ <style type="text/css">
+  .st0{fill:#FFFFFF;}
+ </style>
+ <metadata>
+  <sfw xmlns="ns_sfw;">
+   <slices>
+   </slices>
+   <sliceSourceBounds bottomLeftOrigin="true" height="65" width="92.2" x="-43.7" y="-98">
+   </sliceSourceBounds>
+  </sfw>
+ </metadata>
+ <path class="st0" d="M66.5,0H52.4l25.7,65h14.1L66.5,0z M25.7,0L0,65h14.4l5.3-13.6h26.9L51.8,65h14.4L40.5,0C40.5,0,25.7,0,25.7,0z
+	 M24.3,39.3l8.8-22.8l8.8,22.8H24.3z">
+ </path>
+</svg>

frontend/public/Logos/claude-code.svg

@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Claude</title><path d="M4.709 15.955l4.72-2.647.08-.23-.08-.128H9.2l-.79-.048-2.698-.073-2.339-.097-2.266-.122-.571-.121L0 11.784l.055-.352.48-.321.686.06 1.52.103 2.278.158 1.652.097 2.449.255h.389l.055-.157-.134-.098-.103-.097-2.358-1.596-2.552-1.688-1.336-.972-.724-.491-.364-.462-.158-1.008.656-.722.881.06.225.061.893.686 1.908 1.476 2.491 1.833.365.304.145-.103.019-.073-.164-.274-1.355-2.446-1.446-2.49-.644-1.032-.17-.619a2.97 2.97 0 01-.104-.729L6.283.134 6.696 0l.996.134.42.364.62 1.414 1.002 2.229 1.555 3.03.456.898.243.832.091.255h.158V9.01l.128-1.706.237-2.095.23-2.695.08-.76.376-.91.747-.492.584.28.48.685-.067.444-.286 1.851-.559 2.903-.364 1.942h.212l.243-.242.985-1.306 1.652-2.064.73-.82.85-.904.547-.431h1.033l.76 1.129-.34 1.166-1.064 1.347-.881 1.142-1.264 1.7-.79 1.36.073.11.188-.02 2.856-.606 1.543-.28 1.841-.315.833.388.091.395-.328.807-1.969.486-2.309.462-3.439.813-.042.03.049.061 1.549.146.662.036h1.622l3.02.225.79.522.474.638-.079.485-1.215.62-1.64-.389-3.829-.91-1.312-.329h-.182v.11l1.093 1.068 2.006 1.81 2.509 2.33.127.578-.322.455-.34-.049-2.205-1.657-.851-.747-1.926-1.62h-.128v.17l.444.649 2.345 3.521.122 1.08-.17.353-.608.213-.668-.122-1.374-1.925-1.415-2.167-1.143-1.943-.14.08-.674 7.254-.316.37-.729.28-.607-.461-.322-.747.322-1.476.389-1.924.315-1.53.286-1.9.17-.632-.012-.042-.14.018-1.434 1.967-2.18 2.945-1.726 1.845-.414.164-.717-.37.067-.662.401-.589 2.388-3.036 1.44-1.882.93-1.086-.006-.158h-.055L4.132 18.56l-1.13.146-.487-.456.061-.746.231-.243 1.908-1.312-.006.006z" fill="#D97757" fill-rule="nonzero"></path></svg>

frontend/public/Logos/deepseek.svg

@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>DeepSeek</title><path d="M23.748 4.482c-.254-.124-.364.113-.512.234-.051.039-.094.09-.137.136-.372.397-.806.657-1.373.626-.829-.046-1.537.214-2.163.848-.133-.782-.575-1.248-1.247-1.548-.352-.156-.708-.311-.955-.65-.172-.241-.219-.51-.305-.774-.055-.16-.11-.323-.293-.35-.2-.031-.278.136-.356.276-.313.572-.434 1.202-.422 1.84.027 1.436.633 2.58 1.838 3.393.137.093.172.187.129.323-.082.28-.18.552-.266.833-.055.179-.137.217-.329.14a5.526 5.526 0 01-1.736-1.18c-.857-.828-1.631-1.742-2.597-2.458a11.365 11.365 0 00-.689-.471c-.985-.957.13-1.743.388-1.836.27-.098.093-.432-.779-.428-.872.004-1.67.295-2.687.684a3.055 3.055 0 01-.465.137 9.597 9.597 0 00-2.883-.102c-1.885.21-3.39 1.102-4.497 2.623C.082 8.606-.231 10.684.152 12.85c.403 2.284 1.569 4.175 3.36 5.653 1.858 1.533 3.997 2.284 6.438 2.14 1.482-.085 3.133-.284 4.994-1.86.47.234.962.327 1.78.397.63.059 1.236-.03 1.705-.128.735-.156.684-.837.419-.961-2.155-1.004-1.682-.595-2.113-.926 1.096-1.296 2.746-2.642 3.392-7.003.05-.347.007-.565 0-.845-.004-.17.035-.237.23-.256a4.173 4.173 0 001.545-.475c1.396-.763 1.96-2.015 2.093-3.517.02-.23-.004-.467-.247-.588zM11.581 18c-2.089-1.642-3.102-2.183-3.52-2.16-.392.024-.321.471-.235.763.09.288.207.486.371.739.114.167.192.416-.113.603-.673.416-1.842-.14-1.897-.167-1.361-.802-2.5-1.86-3.301-3.307-.774-1.393-1.224-2.887-1.298-4.482-.02-.386.093-.522.477-.592a4.696 4.696 0 011.529-.039c2.132.312 3.946 1.265 5.468 2.774.868.86 1.525 1.887 2.202 2.891.72 1.066 1.494 2.082 2.48 2.914.348.292.625.514.891.677-.802.09-2.14.11-3.054-.614zm1-6.44a.306.306 0 01.415-.287.302.302 0 01.2.288.306.306 0 01-.31.307.303.303 0 01-.304-.308zm3.11 1.596c-.2.081-.399.151-.59.16a1.245 1.245 0 01-.798-.254c-.274-.23-.47-.358-.552-.758a1.73 1.73 0 01.016-.588c.07-.327-.008-.537-.239-.727-.187-.156-.426-.199-.688-.199a.559.559 0 01-.254-.078c-.11-.054-.2-.19-.114-.358.028-.054.16-.186.192-.21.356-.202.767-.136 1.146.016.352.144.618.408 1.001.782.391.451.462.576.685.914.176.265.336.537.445.848.067.195-.019.354-.25.452z" fill="#4D6BFE"></path></svg>

frontend/public/Logos/google-gemini.svg

@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Gemini</title><path d="M20.616 10.835a14.147 14.147 0 01-4.45-3.001 14.111 14.111 0 01-3.678-6.452.503.503 0 00-.975 0 14.134 14.134 0 01-3.679 6.452 14.155 14.155 0 01-4.45 3.001c-.65.28-1.318.505-2.002.678a.502.502 0 000 .975c.684.172 1.35.397 2.002.677a14.147 14.147 0 014.45 3.001 14.112 14.112 0 013.679 6.453.502.502 0 00.975 0c.172-.685.397-1.351.677-2.003a14.145 14.145 0 013.001-4.45 14.113 14.113 0 016.453-3.678.503.503 0 000-.975 13.245 13.245 0 01-2.003-.678z" fill="#3186FF"></path><path d="M20.616 10.835a14.147 14.147 0 01-4.45-3.001 14.111 14.111 0 01-3.678-6.452.503.503 0 00-.975 0 14.134 14.134 0 01-3.679 6.452 14.155 14.155 0 01-4.45 3.001c-.65.28-1.318.505-2.002.678a.502.502 0 000 .975c.684.172 1.35.397 2.002.677a14.147 14.147 0 014.45 3.001 14.112 14.112 0 013.679 6.453.502.502 0 00.975 0c.172-.685.397-1.351.677-2.003a14.145 14.145 0 013.001-4.45 14.113 14.113 0 016.453-3.678.503.503 0 000-.975 13.245 13.245 0 01-2.003-.678z" fill="url(#lobe-icons-gemini-fill-0)"></path><path d="M20.616 10.835a14.147 14.147 0 01-4.45-3.001 14.111 14.111 0 01-3.678-6.452.503.503 0 00-.975 0 14.134 14.134 0 01-3.679 6.452 14.155 14.155 0 01-4.45 3.001c-.65.28-1.318.505-2.002.678a.502.502 0 000 .975c.684.172 1.35.397 2.002.677a14.147 14.147 0 014.45 3.001 14.112 14.112 0 013.679 6.453.502.502 0 00.975 0c.172-.685.397-1.351.677-2.003a14.145 14.145 0 013.001-4.45 14.113 14.113 0 016.453-3.678.503.503 0 000-.975 13.245 13.245 0 01-2.003-.678z" fill="url(#lobe-icons-gemini-fill-1)"></path><path d="M20.616 10.835a14.147 14.147 0 01-4.45-3.001 14.111 14.111 0 01-3.678-6.452.503.503 0 00-.975 0 14.134 14.134 0 01-3.679 6.452 14.155 14.155 0 01-4.45 3.001c-.65.28-1.318.505-2.002.678a.502.502 0 000 .975c.684.172 1.35.397 2.002.677a14.147 14.147 0 014.45 3.001 14.112 14.112 0 013.679 6.453.502.502 0 00.975 0c.172-.685.397-1.351.677-2.003a14.145 14.145 0 013.001-4.45 14.113 14.113 0 016.453-3.678.503.503 0 000-.975 13.245 13.245 0 01-2.003-.678z" fill="url(#lobe-icons-gemini-fill-2)"></path><defs><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-gemini-fill-0" x1="7" x2="11" y1="15.5" y2="12"><stop stop-color="#08B962"></stop><stop offset="1" stop-color="#08B962" stop-opacity="0"></stop></linearGradient><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-gemini-fill-1" x1="8" x2="11.5" y1="5.5" y2="11"><stop stop-color="#F94543"></stop><stop offset="1" stop-color="#F94543" stop-opacity="0"></stop></linearGradient><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-gemini-fill-2" x1="3.5" x2="17.5" y1="13.5" y2="12"><stop stop-color="#FABC12"></stop><stop offset=".46" stop-color="#FABC12" stop-opacity="0"></stop></linearGradient></defs></svg>

frontend/public/Logos/langchain.svg

@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>LangChain</title><path d="M8.373 14.502c.013-.06.024-.118.038-.17l.061.145c.115.28.229.557.506.714-.012.254-.334.357-.552.326-.048-.114-.115-.228-.255-.164-.143.056-.3-.01-.266-.185.333-.012.407-.371.468-.666zM18.385 9.245c-.318 0-.616.122-.839.342l-.902.887c-.243.24-.368.572-.343.913l.006.056c.032.262.149.498.337.682.13.128.273.21.447.266a.866.866 0 01-.247.777l-.056.055a2.022 2.022 0 01-1.355-1.555l-.01-.057-.046.037c-.03.024-.06.05-.088.078l-.902.887a1.156 1.156 0 000 1.65c.231.228.535.342.84.342.304 0 .607-.114.838-.341l.902-.888a1.156 1.156 0 00-.436-1.921.953.953 0 01.276-.842 2.062 2.062 0 011.371 1.57l.01.057.047-.037c.03-.024.06-.05.088-.078l.902-.888a1.155 1.155 0 000-1.65 1.188 1.188 0 00-.84-.342z" fill="#1C3C3C"></path><path clip-rule="evenodd" d="M17.901 6H6.1C2.736 6 0 8.692 0 12s2.736 6 6.099 6H17.9C21.264 18 24 15.308 24 12s-2.736-6-6.099-6zm-5.821 9.407c-.195.04-.414.047-.562-.106-.045.1-.136.077-.221.056a.797.797 0 00-.061-.014c-.01.025-.017.048-.026.073-.329.021-.575-.309-.732-.558a4.991 4.991 0 00-.473-.21c-.172-.07-.345-.14-.509-.23a2.218 2.218 0 00-.004.173c-.002.244-.004.503-.227.651-.007.295.236.292.476.29.207-.003.41-.005.447.184a.485.485 0 01-.05.003c-.046 0-.092 0-.127.034-.117.111-.242.063-.372.013-.12-.046-.243-.094-.367-.02a2.318 2.318 0 00-.262.154.97.97 0 01-.548.194c-.024-.036-.014-.059.006-.08a.562.562 0 00.043-.056c.019-.028.035-.057.051-.084.054-.095.103-.18.242-.22-.185-.029-.344.055-.5.137l-.004.002a4.21 4.21 0 01-.065.034c-.097.04-.154.009-.212-.023-.082-.045-.168-.092-.376.04-.04-.032-.02-.061.002-.086.091-.109.21-.125.345-.119-.351-.193-.604-.056-.81.055-.182.098-.327.176-.471-.012-.065.017-.102.063-.138.108-.015.02-.03.038-.047.055-.035-.039-.027-.083-.018-.128l.005-.026a.242.242 0 00.003-.03l-.027-.01c-.053-.022-.105-.044-.09-.124-.117-.04-.2.03-.286.094-.054-.041-.01-.095.032-.145a.279.279 0 00.045-.065c.038-.065.103-.067.166-.069.054-.001.108-.003.145-.042.133-.075.297-.036.462.003.121.028.242.057.354.042.203.025.454-.18.352-.385-.186-.233-.184-.528-.183-.813v-.143c-.016-.108-.172-.233-.328-.358-.12-.095-.24-.191-.298-.28-.16-.177-.285-.382-.409-.585l-.015-.024c-.212-.404-.297-.86-.382-1.315-.103-.546-.205-1.09-.526-1.54-.266.144-.612.075-.841-.118-.12.107-.13.247-.138.396l-.001.014c-.297-.292-.26-.844-.023-1.17.097-.128.213-.233.342-.326.03-.021.04-.042.039-.074.235-1.04 1.836-.839 2.342-.103.167.206.281.442.395.678.137.283.273.566.5.795.22.237.452.463.684.689.359.35.718.699 1.032 1.089.49.587.839 1.276 1.144 1.97.05.092.08.193.11.293.044.15.089.299.2.417.026.035.084.088.149.148.156.143.357.328.289.409.009.019.027.04.05.06.032.028.074.058.116.088.122.087.25.178.16.25zm7.778-3.545l-.902.887c-.24.237-.537.413-.859.51l-.017.005-.006.015A2.021 2.021 0 0117.6 14l-.902.888c-.393.387-.916.6-1.474.6-.557 0-1.08-.213-1.474-.6a2.03 2.03 0 010-2.9l.902-.888c.242-.238.531-.409.859-.508l.016-.004.006-.016c.105-.272.265-.516.475-.724l.902-.887c.393-.387.917-.6 1.474-.6.558 0 1.08.213 1.474.6.394.387.61.902.61 1.45 0 .549-.216 1.064-.61 1.45v.001z" fill="#1C3C3C" fill-rule="evenodd"></path></svg>

frontend/public/Logos/llamaindex.svg

@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>LlamaIndex</title><path d="M15.855 17.122c-2.092.924-4.358.545-5.23.24 0 .21-.01.857-.048 1.78-.038.924-.332 1.507-.475 1.684.016.577.029 1.837-.047 2.26a1.93 1.93 0 01-.476.914H8.295c.114-.577.555-.946.761-1.058.114-1.193-.11-2.229-.238-2.597-.126.449-.437 1.49-.665 2.068a6.418 6.418 0 01-.713 1.299h-.951c-.048-.578.27-.77.475-.77.095-.177.323-.731.476-1.54.152-.807-.064-2.324-.19-2.981v-2.068c-1.522-.818-2.092-1.636-2.473-2.55-.304-.73-.222-1.843-.142-2.308-.096-.176-.373-.625-.476-1.25-.142-.866-.063-1.491 0-1.828-.095-.096-.285-.587-.285-1.78 0-1.192.349-1.811.523-1.972v-.529c-.666-.048-1.331-.336-1.712-.721-.38-.385-.095-.962.143-1.154.238-.193.475-.049.808-.145.333-.096.618-.192.76-.48C4.512 1.403 4.287.448 4.16 0c.57.077.935.577 1.046.818V0c.713.337 1.997 1.154 2.425 2.934.342 1.424.586 4.409.665 5.723 1.823.016 4.137-.26 6.229.193 1.901.412 2.757 1.25 3.755 1.25.999 0 1.57-.577 2.282-.096.714.481 1.094 1.828.999 2.838-.076.808-.697 1.074-.998 1.106-.38 1.27 0 2.485.237 2.934v1.827c.111.16.333.655.333 1.347 0 .693-.222 1.154-.333 1.299.19 1.077-.08 2.18-.238 2.597h-1.283c.152-.385.412-.481.523-.481.228-1.193.063-2.293-.048-2.693-.722-.424-1.188-1.17-1.331-1.491.016.272-.029 1.029-.333 1.875-.304.847-.76 1.347-.95 1.491v1.01h-1.284c0-.615.348-.737.523-.721.222-.4.76-1.01.76-2.212 0-1.015-.713-1.492-1.236-2.405-.248-.434-.127-.978-.047-1.203z" fill="url(#lobe-icons-llama-index-fill)"></path><defs><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-llama-index-fill" x1="4.021" x2="24.613" y1="2.02" y2="19.277"><stop offset=".062" stop-color="#F6DCD9"></stop><stop offset=".326" stop-color="#FFA5EA"></stop><stop offset=".589" stop-color="#45DFF8"></stop><stop offset="1" stop-color="#BC8DEB"></stop></linearGradient></defs></svg>

frontend/public/Logos/mastra.svg

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" width="512" height="512">
+<path d="M0 0 C1.01790619 0.00215515 2.03581238 0.0043103 3.08456421 0.00653076 C17.69363523 0.05620146 32.02575853 0.30709809 46.375 3.3125 C47.34985352 3.51117676 48.32470703 3.70985352 49.32910156 3.91455078 C97.7109774 14.03517194 141.69928269 35.9516877 177.375 70.3125 C178.3640332 71.26068604 178.3640332 71.26068604 179.37304688 72.22802734 C188.86130305 81.37247479 197.6012044 90.66984009 205.375 101.3125 C206.23306152 102.46355017 207.09113451 103.61459177 207.94921875 104.765625 C213.98736829 112.95680614 219.34595521 121.47054105 224.375 130.3125 C224.73948242 130.94430176 225.10396484 131.57610352 225.47949219 132.22705078 C247.08534998 169.97532572 256.85198095 212.74189997 256.6875 255.9375 C256.68534485 256.95540619 256.6831897 257.97331238 256.68096924 259.02206421 C256.63129854 273.63113523 256.38040191 287.96325853 253.375 302.3125 C253.07698486 303.77478027 253.07698486 303.77478027 252.77294922 305.26660156 C242.65232806 353.6484774 220.7358123 397.63678269 186.375 433.3125 C185.74287598 433.97185547 185.11075195 434.63121094 184.45947266 435.31054688 C175.31502521 444.79880305 166.01765991 453.5387044 155.375 461.3125 C154.22394983 462.17056152 153.07290823 463.02863451 151.921875 463.88671875 C143.73224019 469.92427396 135.22961724 475.30707302 126.375 480.3125 C125.66778809 480.7146875 124.96057617 481.116875 124.23193359 481.53125 C101.09654164 494.5566741 75.92537591 503.30551461 49.9375 508.625 C49.21860596 508.77235596 48.49971191 508.91971191 47.7590332 509.0715332 C33.08339502 511.86090125 18.55831162 512.66142619 3.64770508 512.62817383 C0.70811513 512.6250221 -2.2304558 512.64854926 -5.16992188 512.67382812 C-18.54306192 512.71848737 -31.43916711 511.51301542 -44.625 509.3125 C-46.33055054 509.03031616 -46.33055054 509.03031616 -48.07055664 508.74243164 C-91.33802759 500.97044532 -132.38793216 480.98345309 -165.625 452.3125 C-166.37007813 451.67828125 -167.11515625 451.0440625 -167.8828125 450.390625 C-181.38779833 438.57948485 -194.05918743 425.82889772 -204.625 411.3125 C-205.48149066 410.16255169 -206.33826433 409.01281411 -207.1953125 407.86328125 C-213.23534209 399.67315742 -218.61867614 391.16870382 -223.625 382.3125 C-224.0271875 381.60528809 -224.429375 380.89807617 -224.84375 380.16943359 C-237.8691741 357.03404164 -246.61801461 331.86287591 -251.9375 305.875 C-252.08485596 305.15610596 -252.23221191 304.43721191 -252.3840332 303.6965332 C-255.35789088 288.05024391 -255.99800362 272.57681954 -255.9375 256.6875 C-255.93534485 255.66959381 -255.9331897 254.65168762 -255.93096924 253.60293579 C-255.88129854 238.99386477 -255.63040191 224.66174147 -252.625 210.3125 C-252.42632324 209.33764648 -252.22764648 208.36279297 -252.02294922 207.35839844 C-241.90232806 158.9765226 -219.9858123 114.98821731 -185.625 79.3125 C-184.99287598 78.65314453 -184.36075195 77.99378906 -183.70947266 77.31445312 C-174.56502521 67.82619695 -165.26765991 59.0862956 -154.625 51.3125 C-153.47394983 50.45443848 -152.32290823 49.59636549 -151.171875 48.73828125 C-142.98224019 42.70072604 -134.47961724 37.31792698 -125.625 32.3125 C-124.91778809 31.9103125 -124.21057617 31.508125 -123.48193359 31.09375 C-100.34654164 18.0683259 -75.17537591 9.31948539 -49.1875 4 C-48.46860596 3.85264404 -47.74971191 3.70528809 -47.0090332 3.5534668 C-31.36274391 0.57960912 -15.88931954 -0.06050362 0 0 Z " fill="#FAFAFA" transform="translate(255.625,-0.3125)"/>
+<path d="M0 0 C1.01790619 0.00215515 2.03581238 0.0043103 3.08456421 0.00653076 C17.69363523 0.05620146 32.02575853 0.30709809 46.375 3.3125 C47.34985352 3.51117676 48.32470703 3.70985352 49.32910156 3.91455078 C97.7109774 14.03517194 141.69928269 35.9516877 177.375 70.3125 C178.3640332 71.26068604 178.3640332 71.26068604 179.37304688 72.22802734 C188.86130305 81.37247479 197.6012044 90.66984009 205.375 101.3125 C206.23306152 102.46355017 207.09113451 103.61459177 207.94921875 104.765625 C213.98736829 112.95680614 219.34595521 121.47054105 224.375 130.3125 C224.73948242 130.94430176 225.10396484 131.57610352 225.47949219 132.22705078 C247.08534998 169.97532572 256.85198095 212.74189997 256.6875 255.9375 C256.68534485 256.95540619 256.6831897 257.97331238 256.68096924 259.02206421 C256.63129854 273.63113523 256.38040191 287.96325853 253.375 302.3125 C253.07698486 303.77478027 253.07698486 303.77478027 252.77294922 305.26660156 C242.65232806 353.6484774 220.7358123 397.63678269 186.375 433.3125 C185.74287598 433.97185547 185.11075195 434.63121094 184.45947266 435.31054688 C175.31502521 444.79880305 166.01765991 453.5387044 155.375 461.3125 C154.22394983 462.17056152 153.07290823 463.02863451 151.921875 463.88671875 C143.73224019 469.92427396 135.22961724 475.30707302 126.375 480.3125 C125.66778809 480.7146875 124.96057617 481.116875 124.23193359 481.53125 C101.09654164 494.5566741 75.92537591 503.30551461 49.9375 508.625 C49.21860596 508.77235596 48.49971191 508.91971191 47.7590332 509.0715332 C33.08339502 511.86090125 18.55831162 512.66142619 3.64770508 512.62817383 C0.70811513 512.6250221 -2.2304558 512.64854926 -5.16992188 512.67382812 C-18.54306192 512.71848737 -31.43916711 511.51301542 -44.625 509.3125 C-46.33055054 509.03031616 -46.33055054 509.03031616 -48.07055664 508.74243164 C-91.33802759 500.97044532 -132.38793216 480.98345309 -165.625 452.3125 C-166.37007813 451.67828125 -167.11515625 451.0440625 -167.8828125 450.390625 C-181.38779833 438.57948485 -194.05918743 425.82889772 -204.625 411.3125 C-205.48149066 410.16255169 -206.33826433 409.01281411 -207.1953125 407.86328125 C-213.23534209 399.67315742 -218.61867614 391.16870382 -223.625 382.3125 C-224.0271875 381.60528809 -224.429375 380.89807617 -224.84375 380.16943359 C-237.8691741 357.03404164 -246.61801461 331.86287591 -251.9375 305.875 C-252.08485596 305.15610596 -252.23221191 304.43721191 -252.3840332 303.6965332 C-255.35789088 288.05024391 -255.99800362 272.57681954 -255.9375 256.6875 C-255.93534485 255.66959381 -255.9331897 254.65168762 -255.93096924 253.60293579 C-255.88129854 238.99386477 -255.63040191 224.66174147 -252.625 210.3125 C-252.42632324 209.33764648 -252.22764648 208.36279297 -252.02294922 207.35839844 C-241.90232806 158.9765226 -219.9858123 114.98821731 -185.625 79.3125 C-184.99287598 78.65314453 -184.36075195 77.99378906 -183.70947266 77.31445312 C-174.56502521 67.82619695 -165.26765991 59.0862956 -154.625 51.3125 C-153.47394983 50.45443848 -152.32290823 49.59636549 -151.171875 48.73828125 C-142.98224019 42.70072604 -134.47961724 37.31792698 -125.625 32.3125 C-124.91778809 31.9103125 -124.21057617 31.508125 -123.48193359 31.09375 C-100.34654164 18.0683259 -75.17537591 9.31948539 -49.1875 4 C-48.46860596 3.85264404 -47.74971191 3.70528809 -47.0090332 3.5534668 C-31.36274391 0.57960912 -15.88931954 -0.06050362 0 0 Z M-132.625 100.3125 C-133.86636719 101.38757813 -133.86636719 101.38757813 -135.1328125 102.484375 C-165.63578284 129.44938326 -187.86448496 164.37287727 -198.01196289 203.92382812 C-198.4561255 205.654488 -198.91264545 207.38199177 -199.37670898 209.10742188 C-206.39011482 235.81273152 -206.57174532 264.26106754 -201.625 291.3125 C-201.5022168 292.01439453 -201.37943359 292.71628906 -201.25292969 293.43945312 C-191.91867325 346.46214396 -160.92344717 393.42130233 -117.23217773 424.5078125 C-89.1520157 444.03658082 -57.46503366 455.81316968 -23.625 460.3125 C-22.6246875 460.4465625 -21.624375 460.580625 -20.59375 460.71875 C33.68154914 466.46554638 87.79464708 449.50556098 130.05859375 415.375 C172.73532881 380.04170204 197.99757236 331.33192114 204.83984375 276.59375 C205.14411827 273.15919925 205.29014212 269.75985138 205.375 266.3125 C205.40078125 265.47734863 205.4265625 264.64219727 205.453125 263.78173828 C207.08252124 205.19475973 185.21292028 153.59303729 145.375 111.3125 C144.28251953 110.13880859 144.28251953 110.13880859 143.16796875 108.94140625 C136.81651093 102.33070526 129.68927931 96.80369409 122.375 91.3125 C121.54226563 90.68472656 120.70953125 90.05695313 119.8515625 89.41015625 C44.39149597 34.6822923 -62.3071717 39.41419387 -132.625 100.3125 Z " fill="#000000" transform="translate(255.625,-0.3125)"/>
+<path d="M0 0 C0.71623535 0.07524902 1.4324707 0.15049805 2.17041016 0.22802734 C11.41582457 1.31558193 17.53905875 5.69555803 24.37939453 11.60302734 C25.9717539 12.97565167 27.58779464 14.31330925 29.21484375 15.64453125 C39.45353655 24.07849539 49.89302189 32.86357336 58.390625 43.0859375 C59.52771819 44.43830561 60.70999313 45.7532854 61.921875 47.0390625 C78.86561041 65.03405157 92.54732646 86.67485183 103 109 C103.45761719 109.94875 103.91523438 110.8975 104.38671875 111.875 C105.65363083 114.56069375 106.84247298 117.26538924 108 120 C108.70576172 121.65902344 108.70576172 121.65902344 109.42578125 123.3515625 C115.29775985 137.75748334 119.44802749 153.51162791 121 169 C121.1393396 170.13598633 121.1393396 170.13598633 121.28149414 171.29492188 C123.04224228 187.01734848 123.04224228 187.01734848 118.6640625 192.58203125 C115.46027156 195.86702306 111.77976561 198.42626256 108 201 C106.70961638 201.94695663 105.4218661 202.89751165 104.13671875 203.8515625 C54.19558639 240.19218217 -10.15836211 250.82403206 -70.52783203 244.24707031 C-72.70701376 244.02928126 -74.87191381 243.88318722 -77.05859375 243.7734375 C-87.15317474 242.98567756 -93.49567628 238.26267641 -101 232 C-101.5775 231.5270752 -102.155 231.05415039 -102.75 230.56689453 C-113.80888326 221.47972622 -125.20747742 211.94987788 -134.3828125 200.92578125 C-136.24364652 198.70986054 -138.21467717 196.61674763 -140.1875 194.5 C-161.40351648 170.90663702 -177.09305866 142.66632254 -188 113 C-188.40734375 111.93007812 -188.8146875 110.86015625 -189.234375 109.7578125 C-194.48827127 95.16814672 -202.71297728 67.59681209 -195.89453125 52.5625 C-194.07223789 50.69071225 -192.19999029 49.41220499 -190 48 C-188.52096885 46.81314803 -187.04236305 45.62573122 -185.57055664 44.42993164 C-163.09739012 26.47222869 -136.79512656 14.12849151 -109 7 C-107.47898826 6.58659334 -105.95816766 6.17248301 -104.4375 5.7578125 C-70.37699256 -3.34276097 -34.91038892 -3.88896444 0 0 Z " fill="#010101" transform="translate(294,134)"/>
+<path d="M0 0 C0.86409988 -0.0033284 1.72819977 -0.0066568 2.6184845 -0.01008606 C4.43616205 -0.0151155 6.2538487 -0.01749563 8.0715332 -0.01733398 C10.80761482 -0.01951182 13.54328676 -0.03768671 16.27929688 -0.05664062 C26.27760684 -0.08904371 35.78646484 0.35879187 45.64453125 2.16796875 C46.42820068 2.2980835 47.21187012 2.42819824 48.01928711 2.56225586 C67.48091134 5.91708002 86.4354731 13.58908312 103.64453125 23.16796875 C104.27649414 23.51827148 104.90845703 23.86857422 105.55957031 24.22949219 C119.56180482 32.08853758 131.62289424 41.70235966 143.20019531 52.78662109 C144.48254743 54.01304914 145.77750786 55.22626362 147.07421875 56.4375 C160.46125565 69.27666884 171.07943638 85.21359379 179.83203125 101.48046875 C180.23115723 102.21628174 180.6302832 102.95209473 181.04150391 103.71020508 C181.97584067 105.49613991 182.81943883 107.32900956 183.64453125 109.16796875 C183.31453125 109.82796875 182.98453125 110.48796875 182.64453125 111.16796875 C181.77828125 110.23984375 180.91203125 109.31171875 180.01953125 108.35546875 C151.77719444 80.22655498 111.24847041 62.18954649 72.55981445 54.76806641 C66.66500207 53.55440703 62.13035714 50.73600667 57.08203125 47.54296875 C55.29699984 46.44819083 53.51053116 45.35575303 51.72265625 44.265625 C50.85318359 43.73340332 49.98371094 43.20118164 49.08789062 42.65283203 C16.63913044 22.93327173 -19.64835388 13.71677996 -57.35546875 13.16796875 C-51.06422023 6.87672023 -37.42242063 5.35193024 -28.98046875 3.41796875 C-28.06620117 3.20744873 -27.15193359 2.99692871 -26.20996094 2.7800293 C-17.46378901 0.84110933 -8.95226967 0.0123532 0 0 Z " fill="#030303" transform="translate(244.35546875,67.83203125)"/>
+<path d="M0 0 C1.3921875 1.2065625 1.3921875 1.2065625 2.8125 2.4375 C17.70081221 15.15211863 32.63519217 25.94043322 50 35 C50.65210449 35.34772461 51.30420898 35.69544922 51.97607422 36.05371094 C68.61826436 44.84435504 87.93410811 51.6622374 106.5 54.8125 C117.0495917 56.69262525 125.60341083 62.82215102 134.53027344 68.45361328 C166.82331519 88.67347552 203.35131846 97.02260308 241 98 C234.72437292 104.27562708 221.11199545 105.81088155 212.6875 107.75 C211.78161133 107.96052002 210.87572266 108.17104004 209.94238281 108.38793945 C198.42674064 110.9501174 187.15547289 111.18641307 175.40698242 111.18530273 C172.83560399 111.18748043 170.2646618 111.20566475 167.69335938 111.22460938 C157.60706378 111.25933256 147.96699734 110.68684053 138 109 C137.17717529 108.86456787 136.35435059 108.72913574 135.5065918 108.58959961 C99.40933725 102.18890888 66.71597085 83.54843429 40.46044922 58.39746094 C39.17158965 57.16418909 37.86994193 55.94431172 36.56640625 54.7265625 C21.17388217 39.96510447 9.14707063 21.15582183 0 2 C0 1.34 0 0.68 0 0 Z " fill="#030303" transform="translate(84,333)"/>
+<path d="M0 0 C2.99943905 1.34572887 5.08076179 2.83537101 7.39160156 5.16455078 C8.0319635 5.80506378 8.67232544 6.44557678 9.33209229 7.10549927 C10.01140808 7.79513763 10.69072388 8.484776 11.390625 9.1953125 C12.09523865 9.90275604 12.79985229 10.61019958 13.52581787 11.33908081 C15.7719539 13.59639862 18.01103009 15.86057633 20.25 18.125 C21.77297717 19.65800953 23.29640939 21.19056715 24.8203125 22.72265625 C28.55216815 26.47654573 32.27825351 30.23608914 36 34 C40.8277897 29.9845347 45.3437641 25.77173317 49.73828125 21.2890625 C50.98229394 20.03242542 52.22643824 18.77591862 53.47070312 17.51953125 C55.40594863 15.55930686 57.33953935 13.59749882 59.27075195 11.63330078 C61.15145313 9.72257458 63.03818159 7.81797036 64.92578125 5.9140625 C65.50596512 5.32041901 66.08614899 4.72677551 66.68391418 4.11514282 C68.08510986 2.70514466 69.53810801 1.34696546 71 0 C73 0 73 0 74.62109375 1.609375 C75.22050781 2.31578125 75.81992187 3.0221875 76.4375 3.75 C77.03433594 4.44609375 77.63117188 5.1421875 78.24609375 5.859375 C79.88667532 7.86168836 81.44684965 9.92913287 83 12 C74.42 20.58 65.84 29.16 57 38 C86.7 38.495 86.7 38.495 117 39 C117 44.28 117 49.56 117 55 C97.53 55.33 78.06 55.66 58 56 C66.25 64.25 74.5 72.5 83 81 C81.16614077 84.66771845 79.74937171 86.46834996 76.875 89.25 C76.15054688 89.95640625 75.42609375 90.6628125 74.6796875 91.390625 C74.12539063 91.92171875 73.57109375 92.4528125 73 93 C70.00056095 91.65427113 67.91923821 90.16462899 65.60839844 87.83544922 C64.64785553 86.87467972 64.64785553 86.87467972 63.66790771 85.89450073 C62.98859192 85.20486237 62.30927612 84.515224 61.609375 83.8046875 C60.90476135 83.09724396 60.20014771 82.38980042 59.47418213 81.66091919 C57.2280461 79.40360138 54.98896991 77.13942367 52.75 74.875 C51.22702283 73.34199047 49.70359061 71.80943285 48.1796875 70.27734375 C44.44783185 66.52345427 40.72174649 62.76391086 37 59 C32.16701194 63.02748053 27.61889996 67.24379413 23.19140625 71.7109375 C22.57982162 72.32393707 21.968237 72.93693665 21.33811951 73.56851196 C19.41052441 75.50164564 17.48646072 77.43824987 15.5625 79.375 C14.24567596 80.69684699 12.92862074 82.01846372 11.61132812 83.33984375 C8.40487627 86.55724299 5.20158371 89.77775681 2 93 C-1.41059403 91.39464713 -3.61792484 89.59481099 -6.25 86.875 C-6.95640625 86.15054688 -7.6628125 85.42609375 -8.390625 84.6796875 C-8.92171875 84.12539063 -9.4528125 83.57109375 -10 83 C-8.41570736 79.09154201 -5.73402218 76.47642804 -2.7734375 73.578125 C-1.84450684 72.65418945 -0.91557617 71.73025391 0.04150391 70.77832031 C1.22405762 69.61397461 2.40661133 68.44962891 3.625 67.25 C7.37875 63.5375 11.1325 59.825 15 56 C-14.205 55.505 -14.205 55.505 -44 55 C-44 49.72 -44 44.44 -44 39 C-24.2 38.67 -4.4 38.34 16 38 C7.42 29.42 -1.16 20.84 -10 12 C-8.02 9.69 -6.04 7.38 -4 5 C-2.65807132 3.34024611 -1.32090525 1.67653359 0 0 Z " fill="#FBFBFB" transform="translate(220,210)"/>
+<path d="M0 0 C0.66 0 1.32 0 2 0 C2.10320557 0.85489014 2.10320557 0.85489014 2.20849609 1.72705078 C7.84197412 45.87779718 28.1939551 86.6195367 56 121 C56.42941895 121.53383301 56.85883789 122.06766602 57.30126953 122.61767578 C66.40690991 133.83981661 76.68709229 143.89775823 87 154 C85 155 85 155 83.08325195 154.41430664 C82.30941162 154.08293701 81.53557129 153.75156738 80.73828125 153.41015625 C79.44216919 152.85835693 79.44216919 152.85835693 78.11987305 152.29541016 C77.19343994 151.8885498 76.26700684 151.48168945 75.3125 151.0625 C74.36221924 150.64790527 73.41193848 150.23331055 72.43286133 149.80615234 C39.14146569 135.09423719 7.08477782 112.00144189 -6.8203125 77.16015625 C-7.20960937 76.11730469 -7.59890625 75.07445312 -8 74 C-8.32742187 73.13246094 -8.65484375 72.26492188 -8.9921875 71.37109375 C-16.36268399 50.62841076 -12.86150198 26.97666813 -3.75 7.5625 C-2.52169606 5.02980009 -1.26750366 2.51347207 0 0 Z " fill="#040404" transform="translate(80,210)"/>
+<path d="M0 0 C1.35764345 4.07293036 -0.06910614 6.67744348 -1.5625 10.5 C-1.97749756 11.57531982 -1.97749756 11.57531982 -2.40087891 12.67236328 C-6.47155806 22.9772079 -11.68698526 31.65423127 -19 40 C-19.59296875 40.68835938 -20.1859375 41.37671875 -20.796875 42.0859375 C-35.31857853 57.78675371 -58.56153437 66.83592642 -79.57324219 68.23852539 C-83.59327999 68.37727956 -87.60297433 68.43877365 -91.625 68.4375 C-92.70432297 68.43910126 -92.70432297 68.43910126 -93.80545044 68.44073486 C-120.19044633 68.3846361 -144.22754501 60.94698881 -168 50 C-168 49.67 -168 49.34 -168 49 C-167.23671387 48.98018066 -166.47342773 48.96036133 -165.68701172 48.93994141 C-135.41473945 48.1185831 -105.01412697 46.60137763 -75.89160156 37.58056641 C-74.17234947 37.05289714 -72.4420738 36.56148633 -70.7109375 36.07421875 C-45.39043035 28.79857935 -20.43492118 16.73681044 0 0 Z " fill="#040404" transform="translate(411,347)"/>
+<path d="M0 0 C36.3336157 11.02984762 71.78280942 35.12814008 90.01855469 69.06640625 C96.50040978 81.83662823 99.34867561 93.65420512 99.25 107.9375 C99.26160156 109.61102539 99.26160156 109.61102539 99.2734375 111.31835938 C99.25018103 121.24305766 97.70881388 129.9522873 94.125 139.1875 C93.88136719 139.84685547 93.63773437 140.50621094 93.38671875 141.18554688 C91.65503117 145.7390777 89.50393006 149.82136348 87 154 C86.34 153.67 85.68 153.34 85 153 C84.50097656 151.18432617 84.50097656 151.18432617 84.140625 148.79296875 C83.99786133 147.90649658 83.85509766 147.02002441 83.70800781 146.10668945 C83.55686523 145.14335693 83.40572266 144.18002441 83.25 143.1875 C79.16249798 119.24447032 70.31517306 97.3963538 59 76 C58.48832275 75.02450195 58.48832275 75.02450195 57.96630859 74.02929688 C47.301887 53.8627614 33.39273041 35.47640491 17.7265625 18.9375 C15.86858655 16.97059803 14.11773128 14.95405655 12.41015625 12.85546875 C10.3273051 10.38777963 8.28787438 8.36653406 5.8125 6.3125 C3.31942756 4.23891203 1.82972289 2.74458434 0 0 Z " fill="#040404" transform="translate(345,147)"/>
+<path d="M0 0 C1.26231445 0.00491455 2.52462891 0.0098291 3.82519531 0.01489258 C24.5153613 0.27226578 42.86797287 5.22314233 62.125 12.4375 C63.02718262 12.77418701 63.92936523 13.11087402 64.85888672 13.45776367 C66.12949951 13.94660034 66.12949951 13.94660034 67.42578125 14.4453125 C68.55173706 14.87674561 68.55173706 14.87674561 69.70043945 15.31689453 C71.99402845 16.3980708 73.83827422 17.73010316 75.8125 19.3125 C74.90935059 19.3218457 74.00620117 19.33119141 73.07568359 19.34082031 C46.66373358 19.68118909 20.60587941 21.22322233 -5.11425781 27.79150391 C-7.27539495 28.33458759 -9.44421442 28.83079049 -11.6171875 29.32421875 C-39.00925704 35.7635841 -65.52353508 48.25154961 -88.08203125 65.01171875 C-91.1875 67.3125 -91.1875 67.3125 -93.1875 68.3125 C-92.18113049 53.55241391 -82.67422534 39.13895373 -73.1875 28.3125 C-72.59453125 27.62414062 -72.0015625 26.93578125 -71.390625 26.2265625 C-53.12979089 6.48301109 -25.93856094 -0.12102791 0 0 Z " fill="#030303" transform="translate(193.1875,96.6875)"/>
+<path d="M0 0 C0.99 0.33 1.98 0.66 3 1 C2.34 1.66 1.68 2.32 1 3 C0.67 2.01 0.34 1.02 0 0 Z M-9 10 C-9 13 -9 13 -9 13 Z " fill="#E8E8E8" transform="translate(220,210)"/>
+</svg>

frontend/public/Logos/nomad.svg

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="none"><path fill="#06D092" d="M8 0L1 4v8l7 4 7-4V4L8 0zm3.119 8.797L9.254 9.863 7.001 8.65v2.549l-2.118 1.33v-5.33l1.68-1.018 2.332 1.216V4.794l2.23-1.322-.006 5.325z"/></svg>

frontend/public/Logos/opentelemetry.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128">
+  <path fill="#f5a800" d="M67.648 69.797c-5.246 5.25-5.246 13.758 0 19.008 5.25 5.246 13.758 5.246 19.004 0 5.25-5.25 5.25-13.758 0-19.008-5.246-5.246-13.754-5.246-19.004 0Zm14.207 14.219a6.649 6.649 0 0 1-9.41 0 6.65 6.65 0 0 1 0-9.407 6.649 6.649 0 0 1 9.41 0c2.598 2.586 2.598 6.809 0 9.407ZM86.43 3.672l-8.235 8.234a4.17 4.17 0 0 0 0 5.875l32.149 32.149a4.17 4.17 0 0 0 5.875 0l8.234-8.235c1.61-1.61 1.61-4.261 0-5.87L92.29 3.671a4.159 4.159 0 0 0-5.86 0ZM28.738 108.895a3.763 3.763 0 0 0 0-5.31l-4.183-4.187a3.768 3.768 0 0 0-5.313 0l-8.644 8.649-.016.012-2.371-2.375c-1.313-1.313-3.45-1.313-4.75 0-1.313 1.312-1.313 3.449 0 4.75l14.246 14.242a3.353 3.353 0 0 0 4.746 0c1.3-1.313 1.313-3.45 0-4.746l-2.375-2.375.016-.012Zm0 0"/>
+  <path fill="#425cc7" d="M72.297 27.313 54.004 45.605c-1.625 1.625-1.625 4.301 0 5.926L65.3 62.824c7.984-5.746 19.18-5.035 26.363 2.153l9.148-9.149c1.622-1.625 1.622-4.297 0-5.922L78.22 27.313a4.185 4.185 0 0 0-5.922 0ZM60.55 67.585l-6.672-6.672c-1.563-1.562-4.125-1.562-5.684 0l-23.53 23.54a4.036 4.036 0 0 0 0 5.687l13.331 13.332a4.036 4.036 0 0 0 5.688 0l15.132-15.157c-3.199-6.609-2.625-14.593 1.735-20.73Zm0 0"/>
+</svg>

frontend/public/Logos/supabase.svg

@@ -0,0 +1,99 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="64"
+   height="64"
+   viewBox="0 0 64 64"
+   version="1.1"
+   id="svg20"
+   sodipodi:docname="supabase-icon.svg"
+   style="fill:none"
+   inkscape:version="0.92.4 (5da689c313, 2019-01-14)">
+  <metadata
+     id="metadata24">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1687"
+     inkscape:window-height="849"
+     id="namedview22"
+     showgrid="false"
+     inkscape:zoom="2.0884956"
+     inkscape:cx="54.5"
+     inkscape:cy="56.5"
+     inkscape:window-x="70"
+     inkscape:window-y="0"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="svg20" />
+  <path
+     d="m 37.41219,62.936701 c -1.634985,2.05896 -4.950068,0.93085 -4.989463,-1.69817 L 31.846665,22.786035 h 25.855406 c 4.683108,0 7.294967,5.409033 4.382927,9.07673 z"
+     id="path2"
+     style="fill:url(#paint0_linear);stroke-width:0.57177335"
+     inkscape:connector-curvature="0" />
+  <path
+     d="m 37.41219,62.936701 c -1.634985,2.05896 -4.950068,0.93085 -4.989463,-1.69817 L 31.846665,22.786035 h 25.855406 c 4.683108,0 7.294967,5.409033 4.382927,9.07673 z"
+     id="path4"
+     style="fill:url(#paint1_linear);fill-opacity:0.2;stroke-width:0.57177335"
+     inkscape:connector-curvature="0" />
+  <path
+     d="m 26.89694,1.0634102 c 1.634986,-2.05918508 4.950125,-0.93090008 4.989521,1.698149 L 32.138899,41.214003 H 6.607076 c -4.6832501,0 -7.29518376,-5.409032 -4.3830007,-9.07673 z"
+     id="path6"
+     inkscape:connector-curvature="0"
+     style="fill:#3ecf8e;stroke-width:0.57177335" />
+  <defs
+     id="defs18">
+    <linearGradient
+       id="paint0_linear"
+       x1="53.973801"
+       y1="54.973999"
+       x2="94.163498"
+       y2="71.829498"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.57177306,0,0,0.57177334,0.98590077,-0.12074988)">
+      <stop
+         stop-color="#249361"
+         id="stop8" />
+      <stop
+         offset="1"
+         stop-color="#3ECF8E"
+         id="stop10" />
+    </linearGradient>
+    <linearGradient
+       id="paint1_linear"
+       x1="36.1558"
+       y1="30.577999"
+       x2="54.484402"
+       y2="65.080597"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.57177306,0,0,0.57177334,0.98590077,-0.12074988)">
+      <stop
+         id="stop13" />
+      <stop
+         offset="1"
+         stop-opacity="0"
+         id="stop15" />
+    </linearGradient>
+  </defs>
+</svg>

frontend/src/AppRoutes/index.tsx

@@ -27,6 +27,7 @@ import { IUser } from 'providers/App/types';
 import { DashboardProvider } from 'providers/Dashboard/Dashboard';
 import { ErrorModalProvider } from 'providers/ErrorModalProvider';
 import { KBarCommandPaletteProvider } from 'providers/KBarCommandPaletteProvider';
+import { PreferenceContextProvider } from 'providers/preferences/context/PreferenceContextProvider';
 import { QueryBuilderProvider } from 'providers/QueryBuilder';
 import { Suspense, useCallback, useEffect, useState } from 'react';
 import { Route, Router, Switch } from 'react-router-dom';
@@ -382,20 +383,22 @@ function App(): JSX.Element {
 													<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>
+																<PreferenceContextProvider>
+																	<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>
+																</PreferenceContextProvider>
 															</AppLayout>
 														</AlertRuleProvider>
 													</KeyboardHotkeysProvider>

frontend/src/AppRoutes/utils.ts

@@ -2,14 +2,12 @@ import setLocalStorageApi from 'api/browser/localstorage/set';
 import { LOCALSTORAGE } from 'constants/localStorage';
 
 const afterLogin = (
-	userId: string,
 	authToken: string,
 	refreshToken: string,
 	interceptorRejected?: boolean,
 ): void => {
 	setLocalStorageApi(LOCALSTORAGE.AUTH_TOKEN, authToken);
 	setLocalStorageApi(LOCALSTORAGE.REFRESH_AUTH_TOKEN, refreshToken);
-	setLocalStorageApi(LOCALSTORAGE.USER_ID, userId);
 	setLocalStorageApi(LOCALSTORAGE.IS_LOGGED_IN, 'true');
 
 	if (!interceptorRejected) {
@@ -18,7 +16,6 @@ const afterLogin = (
 				detail: {
 					accessJWT: authToken,
 					refreshJWT: refreshToken,
-					id: userId,
 				},
 			}),
 		);

frontend/src/api/common/getQueryStats.ts

@@ -1,62 +0,0 @@
-import getLocalStorageApi from 'api/browser/localstorage/get';
-import { ENVIRONMENT } from 'constants/env';
-import { LOCALSTORAGE } from 'constants/localStorage';
-import { isEmpty } from 'lodash-es';
-
-export interface WsDataEvent {
-	read_rows: number;
-	read_bytes: number;
-	elapsed_ms: number;
-}
-interface GetQueryStatsProps {
-	queryId: string;
-	setData: React.Dispatch<React.SetStateAction<WsDataEvent | undefined>>;
-}
-
-function getURL(baseURL: string, queryId: string): URL | string {
-	if (baseURL && !isEmpty(baseURL)) {
-		return `${baseURL}/ws/query_progress?q=${queryId}`;
-	}
-	const url = new URL(`/ws/query_progress?q=${queryId}`, window.location.href);
-
-	if (window.location.protocol === 'http:') {
-		url.protocol = 'ws';
-	} else {
-		url.protocol = 'wss';
-	}
-
-	return url;
-}
-
-export function getQueryStats(props: GetQueryStatsProps): void {
-	const { queryId, setData } = props;
-
-	const token = getLocalStorageApi(LOCALSTORAGE.AUTH_TOKEN) || '';
-
-	// https://github.com/whatwg/websockets/issues/20 reason for not using the relative URLs
-	const url = getURL(ENVIRONMENT.wsURL, queryId);
-
-	const socket = new WebSocket(url, token);
-
-	socket.addEventListener('message', (event) => {
-		try {
-			const parsedData = JSON.parse(event?.data);
-			setData(parsedData);
-		} catch {
-			setData(event?.data);
-		}
-	});
-
-	socket.addEventListener('error', (event) => {
-		console.error(event);
-	});
-
-	socket.addEventListener('close', (event) => {
-		// 1000 is a normal closure status code
-		if (event.code !== 1000) {
-			console.error('WebSocket closed with error:', event);
-		} else {
-			console.error('WebSocket closed normally.');
-		}
-	});
-}

frontend/src/api/index.ts

@@ -2,7 +2,7 @@
 /* eslint-disable no-param-reassign */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import getLocalStorageApi from 'api/browser/localstorage/get';
-import loginApi from 'api/v1/login/login';
+import post from 'api/v2/sessions/rotate/post';
 import afterLogin from 'AppRoutes/utils';
 import axios, {
 	AxiosError,
@@ -12,6 +12,7 @@ import axios, {
 import { ENVIRONMENT } from 'constants/env';
 import { Events } from 'constants/events';
 import { LOCALSTORAGE } from 'constants/localStorage';
+import { QueryClient } from 'react-query';
 import { eventEmitter } from 'utils/getEventEmitter';
 
 import apiV1, {
@@ -26,6 +27,14 @@ import apiV1, {
 import { Logout } from './utils';
 
 const RESPONSE_TIMEOUT_THRESHOLD = 5000; // 5 seconds
+const queryClient = new QueryClient({
+	defaultOptions: {
+		queries: {
+			refetchOnWindowFocus: false,
+			retry: false,
+		},
+	},
+});
 
 const interceptorsResponse = (
 	value: AxiosResponse<any>,
@@ -74,19 +83,24 @@ const interceptorRejected = async (
 	try {
 		if (axios.isAxiosError(value) && value.response) {
 			const { response } = value;
-			// reject the refresh token error
-			if (response.status === 401 && response.config.url !== '/login') {
+
+			if (
+				response.status === 401 &&
+				// if the session rotate call errors out with 401 or the delete sessions call returns 401 then we do not retry!
+				response.config.url !== '/sessions/rotate' &&
+				!(
+					response.config.url === '/sessions' && response.config.method === 'delete'
+				)
+			) {
 				try {
-					const response = await loginApi({
-						refreshToken: getLocalStorageApi(LOCALSTORAGE.REFRESH_AUTH_TOKEN) || '',
+					const accessToken = getLocalStorageApi(LOCALSTORAGE.AUTH_TOKEN);
+					const refreshToken = getLocalStorageApi(LOCALSTORAGE.REFRESH_AUTH_TOKEN);
+					const response = await queryClient.fetchQuery({
+						queryFn: () => post({ refreshToken: refreshToken || '' }),
+						queryKey: ['/api/v2/sessions/rotate', accessToken, refreshToken],
 					});
 
-					afterLogin(
-						response.data.userId,
-						response.data.accessJwt,
-						response.data.refreshJwt,
-						true,
-					);
+					afterLogin(response.data.accessToken, response.data.refreshToken, true);
 
 					try {
 						const reResponse = await axios(
@@ -95,7 +109,7 @@ const interceptorRejected = async (
 								method: value.config.method,
 								headers: {
 									...value.config.headers,
-									Authorization: `Bearer ${response.data.accessJwt}`,
+									Authorization: `Bearer ${response.data.accessToken}`,
 								},
 								data: {
 									...JSON.parse(value.config.data || '{}'),
@@ -113,8 +127,8 @@ const interceptorRejected = async (
 					Logout();
 				}
 			}
-			// when refresh token is expired
-			if (response.status === 401 && response.config.url === '/login') {
+
+			if (response.status === 401 && response.config.url === '/sessions/rotate') {
 				Logout();
 			}
 		}

frontend/src/api/utils.ts

@@ -3,7 +3,15 @@ import { LOCALSTORAGE } from 'constants/localStorage';
 import ROUTES from 'constants/routes';
 import history from 'lib/history';
 
-export const Logout = (): void => {
+import deleteSession from './v2/sessions/delete';
+
+export const Logout = async (): Promise<void> => {
+	try {
+		await deleteSession();
+	} catch (error) {
+		console.error(error);
+	}
+
 	deleteLocalStorageKey(LOCALSTORAGE.AUTH_TOKEN);
 	deleteLocalStorageKey(LOCALSTORAGE.IS_LOGGED_IN);
 	deleteLocalStorageKey(LOCALSTORAGE.IS_IDENTIFIED_USER);
@@ -14,7 +22,6 @@ export const Logout = (): void => {
 	deleteLocalStorageKey(LOCALSTORAGE.USER_ID);
 	deleteLocalStorageKey(LOCALSTORAGE.QUICK_FILTERS_SETTINGS_ANNOUNCEMENT);
 	window.dispatchEvent(new CustomEvent('LOGOUT'));
-
 	history.push(ROUTES.LOGIN);
 };
 

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

@@ -2,11 +2,10 @@ 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>> => {
+const deleteDomain = async (id: string): Promise<SuccessResponseV2<null>> => {
 	try {
-		const response = await axios.delete<PayloadProps>(`/domains/${props.id}`);
+		const response = await axios.delete<null>(`/domains/${id}`);
 
 		return {
 			httpStatusCode: response.status,

frontend/src/api/v1/domains/id/put.ts

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

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

@@ -1,12 +1,16 @@
 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';
+import { ErrorV2Resp, RawSuccessResponse, SuccessResponseV2 } from 'types/api';
+import { GettableAuthDomain } from 'types/api/v1/domains/list';
 
-const listAllDomain = async (): Promise<SuccessResponseV2<AuthDomain[]>> => {
+const listAllDomain = async (): Promise<
+	SuccessResponseV2<GettableAuthDomain[]>
+> => {
 	try {
-		const response = await axios.get<PayloadProps>(`/domains`);
+		const response = await axios.get<RawSuccessResponse<GettableAuthDomain[]>>(
+			`/domains`,
+		);
 
 		return {
 			httpStatusCode: response.status,

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

@@ -0,0 +1,26 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, RawSuccessResponse, SuccessResponseV2 } from 'types/api';
+import { GettableAuthDomain } from 'types/api/v1/domains/list';
+import { PostableAuthDomain } from 'types/api/v1/domains/post';
+
+const post = async (
+	props: PostableAuthDomain,
+): Promise<SuccessResponseV2<GettableAuthDomain>> => {
+	try {
+		const response = await axios.post<RawSuccessResponse<GettableAuthDomain>>(
+			`/domains`,
+			props,
+		);
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default post;

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

@@ -1,23 +0,0 @@
-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/invite/id/accept.ts

@@ -2,15 +2,12 @@ import axios from 'api';
 import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
 import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
-import {
-	LoginPrecheckResponse,
-	PayloadProps,
-	Props,
-} from 'types/api/user/accept';
+import { PayloadProps, Props } from 'types/api/user/accept';
+import { UserResponse } from 'types/api/user/getUser';
 
 const accept = async (
 	props: Props,
-): Promise<SuccessResponseV2<LoginPrecheckResponse>> => {
+): Promise<SuccessResponseV2<UserResponse>> => {
 	try {
 		const response = await axios.post<PayloadProps>(`/invite/accept`, props);
 		return {

frontend/src/api/v1/login/loginPrecheck.ts

@@ -1,28 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
-import { AxiosError } from 'axios';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { Props, Signup as PayloadProps } from 'types/api/user/loginPrecheck';
-
-const loginPrecheck = async (
-	props: Props,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	try {
-		const response = await axios.get(
-			`/loginPrecheck?email=${encodeURIComponent(
-				props.email,
-			)}&ref=${encodeURIComponent(window.location.href)}`,
-		);
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: response.statusText,
-			payload: response.data.data,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};
-
-export default loginPrecheck;

frontend/src/api/v1/register/post.ts

@@ -0,0 +1,27 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, RawSuccessResponse, SuccessResponseV2 } from 'types/api';
+import { Props } from 'types/api/user/signup';
+import { SignupResponse } from 'types/api/v1/register/post';
+
+const post = async (
+	props: Props,
+): Promise<SuccessResponseV2<SignupResponse>> => {
+	try {
+		const response = await axios.post<RawSuccessResponse<SignupResponse>>(
+			`/register`,
+			{
+				...props,
+			},
+		);
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default post;

frontend/src/api/v1/register/signup.ts

@@ -1,22 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
-import { AxiosError } from 'axios';
-import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
-import { PayloadProps, Signup } from 'types/api/user/loginPrecheck';
-import { Props } from 'types/api/user/signup';
-
-const signup = async (props: Props): Promise<SuccessResponseV2<Signup>> => {
-	try {
-		const response = await axios.post<PayloadProps>(`/register`, {
-			...props,
-		});
-		return {
-			httpStatusCode: response.status,
-			data: response.data.data,
-		};
-	} catch (error) {
-		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
-	}
-};
-
-export default signup;

frontend/src/api/v1/user/me/get.ts

@@ -2,15 +2,11 @@ import axios from 'api';
 import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
 import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
-import { PayloadProps, Props, UserLoginResponse } from 'types/api/user/login';
+import { PayloadProps, UserResponse } from 'types/api/user/getUser';
 
-const login = async (
-	props: Props,
-): Promise<SuccessResponseV2<UserLoginResponse>> => {
+const get = async (): Promise<SuccessResponseV2<UserResponse>> => {
 	try {
-		const response = await axios.post<PayloadProps>(`/login`, {
-			...props,
-		});
+		const response = await axios.get<PayloadProps>(`/user/me`);
 
 		return {
 			httpStatusCode: response.status,
@@ -21,4 +17,4 @@ const login = async (
 	}
 };
 
-export default login;
+export default get;

frontend/src/api/v1/version/get.ts

@@ -2,20 +2,19 @@ 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';
+import { Info } from 'types/api/v1/version/get';
 
-const create = async (props: Props): Promise<SuccessResponseV2<AuthDomain>> => {
+const get = async (): Promise<SuccessResponseV2<Info>> => {
 	try {
-		const response = await axios.post<PayloadProps>(`/domains`, props);
+		const response = await axios.get<Info>(`/version`);
 
 		return {
 			httpStatusCode: response.status,
-			data: response.data.data,
+			data: response.data,
 		};
 	} catch (error) {
 		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
 	}
 };
 
-export default create;
+export default get;

frontend/src/api/v1/version/getVersion.ts

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

frontend/src/api/v2/sessions/context/get.ts

@@ -0,0 +1,27 @@
+import { ApiV2Instance as axios } from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, RawSuccessResponse, SuccessResponseV2 } from 'types/api';
+import { Props, SessionsContext } from 'types/api/v2/sessions/context/get';
+
+const get = async (
+	props: Props,
+): Promise<SuccessResponseV2<SessionsContext>> => {
+	try {
+		const response = await axios.get<RawSuccessResponse<SessionsContext>>(
+			'/sessions/context',
+			{
+				params: props,
+			},
+		);
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default get;

frontend/src/api/v2/sessions/delete.ts

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

frontend/src/api/v2/sessions/email_password/post.ts

@@ -0,0 +1,23 @@
+import { ApiV2Instance as axios } from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, RawSuccessResponse, SuccessResponseV2 } from 'types/api';
+import { Props, Token } from 'types/api/v2/sessions/email_password/post';
+
+const post = async (props: Props): Promise<SuccessResponseV2<Token>> => {
+	try {
+		const response = await axios.post<RawSuccessResponse<Token>>(
+			'/sessions/email_password',
+			props,
+		);
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default post;

frontend/src/api/v2/sessions/rotate/post.ts

@@ -0,0 +1,23 @@
+import { ApiV2Instance as axios } from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, RawSuccessResponse, SuccessResponseV2 } from 'types/api';
+import { Props, Token } from 'types/api/v2/sessions/rotate/post';
+
+const post = async (props: Props): Promise<SuccessResponseV2<Token>> => {
+	try {
+		const response = await axios.post<RawSuccessResponse<Token>>(
+			'/sessions/rotate',
+			props,
+		);
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default post;

frontend/src/components/ChangelogModal/components/ChangelogRenderer.styles.scss

@@ -99,7 +99,7 @@
 		}
 	}
 
-	& :is(h1, h2, h3, h4, h5, h6, p, &-section-title) {
+	& :is(h1, h2, h3, h4, h5, h6, &-section-title) {
 		font-weight: 600;
 		color: var(--text-vanilla-100, #fff);
 	}

frontend/src/components/HeaderRightSection/HeaderRightSection.tsx

@@ -86,7 +86,9 @@ function HeaderRightSection({
 						className="share-feedback-btn periscope-btn ghost"
 						icon={<SquarePen size={14} />}
 						onClick={handleOpenFeedbackModal}
-					/>
+					>
+						Feedback
+					</Button>
 				</Popover>
 			)}
 

frontend/src/components/SpanHoverCard/SpanHoverCard.tsx

@@ -87,6 +87,7 @@ function SpanHoverCard({
 					</Typography.Text>
 				</div>
 			}
+			mouseEnterDelay={0.5}
 			content={getContent()}
 			trigger="hover"
 			rootClassName="span-hover-card"

frontend/src/components/SpanHoverCard/__tests__/SpanHoverCard.test.tsx

@@ -0,0 +1,258 @@
+import { act, fireEvent, render, screen } from '@testing-library/react';
+import { Span } from 'types/api/trace/getTraceV2';
+
+import SpanHoverCard from '../SpanHoverCard';
+
+// Mock dayjs completely for testing
+jest.mock('dayjs', () => {
+	const mockDayjs = jest.fn(() => ({
+		format: jest.fn((formatString: string) => {
+			if (formatString === 'D/M/YY - HH:mm:ss') {
+				return '15/3/24 - 14:23:45';
+			}
+			return 'mock-date';
+		}),
+	}));
+	Object.assign(mockDayjs, {
+		extend: jest.fn(),
+		tz: { guess: jest.fn(() => 'UTC') },
+	});
+	return mockDayjs;
+});
+
+const HOVER_ELEMENT_ID = 'hover-element';
+
+const mockSpan: Span = {
+	spanId: 'test-span-id',
+	traceId: 'test-trace-id',
+	rootSpanId: 'root-span-id',
+	parentSpanId: 'parent-span-id',
+	name: 'GET /api/users',
+	timestamp: 1679748225000000,
+	durationNano: 150000000,
+	serviceName: 'user-service',
+	kind: 1,
+	hasError: false,
+	level: 1,
+	references: [],
+	tagMap: {},
+	event: [
+		{
+			name: 'event1',
+			timeUnixNano: 1679748225100000,
+			attributeMap: {},
+			isError: false,
+		},
+		{
+			name: 'event2',
+			timeUnixNano: 1679748225200000,
+			attributeMap: {},
+			isError: false,
+		},
+	],
+	rootName: 'root-span',
+	statusMessage: '',
+	statusCodeString: 'OK',
+	spanKind: 'server',
+	hasChildren: false,
+	hasSibling: false,
+	subTreeNodeCount: 1,
+};
+
+const mockTraceMetadata = {
+	startTime: 1679748225000000,
+	endTime: 1679748226000000,
+};
+
+describe('SpanHoverCard', () => {
+	beforeEach(() => {
+		jest.useFakeTimers();
+	});
+
+	afterEach(() => {
+		jest.useRealTimers();
+	});
+
+	it('renders child element correctly', () => {
+		render(
+			<SpanHoverCard span={mockSpan} traceMetadata={mockTraceMetadata}>
+				<div data-testid="child-element">Hover me</div>
+			</SpanHoverCard>,
+		);
+
+		expect(screen.getByTestId('child-element')).toBeInTheDocument();
+		expect(screen.getByText('Hover me')).toBeInTheDocument();
+	});
+
+	it('shows popover after 0.5 second delay on hover', async () => {
+		render(
+			<SpanHoverCard span={mockSpan} traceMetadata={mockTraceMetadata}>
+				<div data-testid={HOVER_ELEMENT_ID}>Hover for details</div>
+			</SpanHoverCard>,
+		);
+
+		const hoverElement = screen.getByTestId(HOVER_ELEMENT_ID);
+
+		// Hover over the element
+		fireEvent.mouseEnter(hoverElement);
+
+		// Popover should NOT appear immediately
+		expect(screen.queryByText('Duration:')).not.toBeInTheDocument();
+
+		// Advance time by 0.5 seconds
+		act(() => {
+			jest.advanceTimersByTime(500);
+		});
+
+		// Now popover should appear
+		expect(screen.getByText('Duration:')).toBeInTheDocument();
+	});
+
+	it('does not show popover if hover is too brief', async () => {
+		render(
+			<SpanHoverCard span={mockSpan} traceMetadata={mockTraceMetadata}>
+				<div data-testid={HOVER_ELEMENT_ID}>Quick hover test</div>
+			</SpanHoverCard>,
+		);
+
+		const hoverElement = screen.getByTestId(HOVER_ELEMENT_ID);
+
+		// Quick hover and unhover
+		fireEvent.mouseEnter(hoverElement);
+		act(() => {
+			jest.advanceTimersByTime(200); // Only 0.2 seconds
+		});
+		fireEvent.mouseLeave(hoverElement);
+
+		// Advance past the full delay
+		act(() => {
+			jest.advanceTimersByTime(400);
+		});
+
+		// Popover should not appear
+		expect(screen.queryByText('Duration:')).not.toBeInTheDocument();
+	});
+
+	it('displays span information in popover content after delay', async () => {
+		render(
+			<SpanHoverCard span={mockSpan} traceMetadata={mockTraceMetadata}>
+				<div data-testid={HOVER_ELEMENT_ID}>Test span</div>
+			</SpanHoverCard>,
+		);
+
+		const hoverElement = screen.getByTestId(HOVER_ELEMENT_ID);
+
+		// Hover and wait for popover
+		fireEvent.mouseEnter(hoverElement);
+		act(() => {
+			jest.advanceTimersByTime(500);
+		});
+
+		// Check that popover shows span operation name in title
+		expect(screen.getByText('GET /api/users')).toBeInTheDocument();
+
+		// Check duration information
+		expect(screen.getByText('Duration:')).toBeInTheDocument();
+		expect(screen.getByText('150ms')).toBeInTheDocument();
+
+		// Check events count
+		expect(screen.getByText('Events:')).toBeInTheDocument();
+		expect(screen.getByText('2')).toBeInTheDocument();
+
+		// Check start time label
+		expect(screen.getByText('Start time:')).toBeInTheDocument();
+	});
+
+	it('displays new date format with seconds', async () => {
+		render(
+			<SpanHoverCard span={mockSpan} traceMetadata={mockTraceMetadata}>
+				<div data-testid={HOVER_ELEMENT_ID}>Date format test</div>
+			</SpanHoverCard>,
+		);
+
+		const hoverElement = screen.getByTestId(HOVER_ELEMENT_ID);
+
+		// Hover and wait for popover
+		fireEvent.mouseEnter(hoverElement);
+		act(() => {
+			jest.advanceTimersByTime(500);
+		});
+
+		// Verify the new date format is displayed
+		expect(screen.getByText('15/3/24 - 14:23:45')).toBeInTheDocument();
+	});
+
+	it('displays relative time information', async () => {
+		const spanWithRelativeTime: Span = {
+			...mockSpan,
+			timestamp: mockTraceMetadata.startTime + 1000000, // 1 second later
+		};
+
+		render(
+			<SpanHoverCard span={spanWithRelativeTime} traceMetadata={mockTraceMetadata}>
+				<div data-testid={HOVER_ELEMENT_ID}>Relative time test</div>
+			</SpanHoverCard>,
+		);
+
+		const hoverElement = screen.getByTestId(HOVER_ELEMENT_ID);
+
+		// Hover and wait for popover
+		fireEvent.mouseEnter(hoverElement);
+		act(() => {
+			jest.advanceTimersByTime(500);
+		});
+
+		// Check relative time display
+		expect(screen.getByText(/after trace start/)).toBeInTheDocument();
+	});
+
+	it('handles spans with no events correctly', async () => {
+		const spanWithoutEvents: Span = {
+			...mockSpan,
+			event: [],
+		};
+
+		render(
+			<SpanHoverCard span={spanWithoutEvents} traceMetadata={mockTraceMetadata}>
+				<div data-testid={HOVER_ELEMENT_ID}>No events test</div>
+			</SpanHoverCard>,
+		);
+
+		const hoverElement = screen.getByTestId(HOVER_ELEMENT_ID);
+
+		// Hover and wait for popover
+		fireEvent.mouseEnter(hoverElement);
+		act(() => {
+			jest.advanceTimersByTime(500);
+		});
+
+		expect(screen.getByText('Events:')).toBeInTheDocument();
+		expect(screen.getByText('0')).toBeInTheDocument();
+	});
+
+	it('verifies mouseEnterDelay prop is set to 0.5', () => {
+		const { container } = render(
+			<SpanHoverCard span={mockSpan} traceMetadata={mockTraceMetadata}>
+				<div data-testid={HOVER_ELEMENT_ID}>Delay test</div>
+			</SpanHoverCard>,
+		);
+
+		// The mouseEnterDelay prop should be set on the Popover component
+		// This test verifies the implementation includes the delay
+		const popover = container.querySelector('.ant-popover');
+		expect(popover).not.toBeInTheDocument(); // Initially not visible
+
+		// Hover to trigger delay mechanism
+		const hoverElement = screen.getByTestId(HOVER_ELEMENT_ID);
+		fireEvent.mouseEnter(hoverElement);
+
+		// Should not appear before delay
+		expect(screen.queryByText('Duration:')).not.toBeInTheDocument();
+
+		// Should appear after delay
+		act(() => {
+			jest.advanceTimersByTime(500);
+		});
+		expect(screen.getByText('Duration:')).toBeInTheDocument();
+	});
+});

frontend/src/constants/api.ts

@@ -1,5 +1,3 @@
 const SOMETHING_WENT_WRONG = 'Something went wrong';
 
-const getVersion = 'version';
-
-export { getVersion, SOMETHING_WENT_WRONG };
+export { SOMETHING_WENT_WRONG };

frontend/src/constants/dateTimeFormats.ts

@@ -29,7 +29,7 @@ export const DATE_TIME_FORMATS = {
 	DATE_SHORT: 'MM/DD',
 	YEAR_SHORT: 'YY',
 	YEAR_MONTH: 'YY-MM',
-	SPAN_POPOVER_DATE: 'M/D/YY - HH:mm',
+	SPAN_POPOVER_DATE: 'D/M/YY - HH:mm:ss',
 
 	// Month name formats
 	MONTH_DATE_FULL: 'MMMM DD, YYYY',

frontend/src/constants/localStorage.ts

@@ -35,4 +35,5 @@ export enum LOCALSTORAGE {
 	SPAN_DETAILS_PINNED_ATTRIBUTES = 'SPAN_DETAILS_PINNED_ATTRIBUTES',
 	LAST_USED_CUSTOM_TIME_RANGES = 'LAST_USED_CUSTOM_TIME_RANGES',
 	SHOW_FREQUENCY_CHART = 'SHOW_FREQUENCY_CHART',
+	DISSMISSED_COST_METER_INFO = 'DISMISSED_COST_METER_INFO',
 }

frontend/src/container/ApiMonitoring/__tests__/EndPointDetails.test.tsx

@@ -22,6 +22,7 @@ import EndPointDetails from '../Explorer/Domains/DomainDetails/EndPointDetails';
 
 // Mock dependencies
 jest.mock('react-query', () => ({
+	...jest.requireActual('react-query'),
 	useQueries: jest.fn(),
 }));
 

frontend/src/container/ApiMonitoring/__tests__/TopErrors.test.tsx

@@ -37,6 +37,7 @@ jest.mock(
 
 // Mock dependencies
 jest.mock('react-query', () => ({
+	...jest.requireActual('react-query'),
 	useQueries: jest.fn(),
 }));
 

frontend/src/container/AppLayout/index.tsx

@@ -12,8 +12,8 @@ import getChangelogByVersion from 'api/changelog/getChangelogByVersion';
 import logEvent from 'api/common/logEvent';
 import manageCreditCardApi from 'api/v1/portal/create';
 import updateUserPreference from 'api/v1/user/preferences/name/update';
+import getUserVersion from 'api/v1/version/get';
 import getUserLatestVersion from 'api/v1/version/getLatestVersion';
-import getUserVersion from 'api/v1/version/getVersion';
 import { AxiosError } from 'axios';
 import cx from 'classnames';
 import ChangelogModal from 'components/ChangelogModal/ChangelogModal';
@@ -317,14 +317,14 @@ function AppLayout(props: AppLayoutProps): JSX.Element {
 			getUserVersionResponse.isFetched &&
 			getUserVersionResponse.isSuccess &&
 			getUserVersionResponse.data &&
-			getUserVersionResponse.data.payload
+			getUserVersionResponse.data.data
 		) {
 			dispatch({
 				type: UPDATE_CURRENT_VERSION,
 				payload: {
-					currentVersion: getUserVersionResponse.data.payload.version,
-					ee: getUserVersionResponse.data.payload.ee,
-					setupCompleted: getUserVersionResponse.data.payload.setupCompleted,
+					currentVersion: getUserVersionResponse.data.data.version,
+					ee: getUserVersionResponse.data.data.ee,
+					setupCompleted: getUserVersionResponse.data.data.setupCompleted,
 				},
 			});
 		}

frontend/src/container/CreateAlertV2/QuerySection/QuerySection.tsx

@@ -25,8 +25,8 @@ function QuerySection(): JSX.Element {
 
 	const alertDef = buildAlertDefForChartPreview({ alertType, thresholdState });
 
-	const onQueryCategoryChange = (val: EQueryType): void => {
-		const query: Query = { ...currentQuery, queryType: val };
+	const onQueryCategoryChange = (queryType: EQueryType): void => {
+		const query: Query = { ...currentQuery, queryType };
 		redirectWithQueryBuilderData(query);
 	};
 

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

@@ -2,16 +2,28 @@
 import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { QueryParams } from 'constants/query';
+import {
+	initialClickHouseData,
+	initialQueryPromQLData,
+} from 'constants/queryBuilder';
 import { AlertDetectionTypes } from 'container/FormAlertRules';
 import { QueryClient, QueryClientProvider } from 'react-query';
 import { Provider } from 'react-redux';
 import { MemoryRouter } from 'react-router-dom';
 import store from 'store';
 import { AlertTypes } from 'types/api/alerts/alertTypes';
+import { EQueryType } from 'types/common/dashboard';
+import { DataSource } from 'types/common/queryBuilder';
 
 import { CreateAlertProvider } from '../../context';
 import QuerySection from '../QuerySection';
 
+jest.mock('uuid', () => ({
+	v4: (): string => 'test-uuid-12345',
+}));
+
+const MOCK_UUID = 'test-uuid-12345';
+
 jest.mock('hooks/queryBuilder/useQueryBuilder', () => ({
 	useQueryBuilder: jest.fn(),
 }));
@@ -48,12 +60,27 @@ jest.mock(
 			queryCategory,
 			alertType,
 			panelType,
+			setQueryCategory,
 		}: any): JSX.Element {
 			return (
 				<div data-testid="query-section-component">
 					<div data-testid="query-category">{queryCategory}</div>
 					<div data-testid="alert-type">{alertType}</div>
 					<div data-testid="panel-type">{panelType}</div>
+					<button
+						type="button"
+						data-testid="change-to-promql"
+						onClick={(): void => setQueryCategory(EQueryType.PROM)}
+					>
+						Change to PromQL
+					</button>
+					<button
+						type="button"
+						data-testid="change-to-query-builder"
+						onClick={(): void => setQueryCategory(EQueryType.QUERY_BUILDER)}
+					>
+						Change to Query Builder
+					</button>
 				</div>
 			);
 		},
@@ -240,17 +267,6 @@ describe('QuerySection', () => {
 		expect(screen.getByTestId('panel-type')).toHaveTextContent('graph');
 	});
 
-	it('has correct CSS classes for tab styling', () => {
-		renderQuerySection();
-
-		const tabs = screen.getAllByRole('button');
-
-		tabs.forEach((tab) => {
-			expect(tab).toHaveClass('list-view-tab');
-			expect(tab).toHaveClass('explorer-view-option');
-		});
-	});
-
 	it('renders with correct container structure', () => {
 		renderQuerySection();
 
@@ -307,4 +323,172 @@ describe('QuerySection', () => {
 		expect(metricsButton).toHaveClass(ACTIVE_TAB_CLASS);
 		expect(logsButton).not.toHaveClass(ACTIVE_TAB_CLASS);
 	});
+
+	it('updates the query data when the alert type changes', async () => {
+		const user = userEvent.setup();
+		renderQuerySection();
+
+		const metricsTab = screen.getByText(METRICS_TEXT);
+		await user.click(metricsTab);
+
+		const result = mockUseQueryBuilder.redirectWithQueryBuilderData.mock.calls[0];
+
+		expect(result[0]).toEqual({
+			id: MOCK_UUID,
+			queryType: EQueryType.QUERY_BUILDER,
+			unit: undefined,
+			builder: {
+				queryData: [
+					expect.objectContaining({
+						dataSource: DataSource.METRICS,
+						queryName: 'A',
+					}),
+				],
+				queryFormulas: [],
+				queryTraceOperator: [],
+			},
+			promql: [initialQueryPromQLData],
+			clickhouse_sql: [initialClickHouseData],
+		});
+
+		expect(result[1]).toEqual({
+			[QueryParams.alertType]: AlertTypes.METRICS_BASED_ALERT,
+			[QueryParams.ruleType]: AlertDetectionTypes.THRESHOLD_ALERT,
+		});
+	});
+
+	it('updates the query data when the query type changes from query_builder to promql', async () => {
+		const user = userEvent.setup();
+		renderQuerySection();
+
+		const changeToPromQLButton = screen.getByTestId('change-to-promql');
+		await user.click(changeToPromQLButton);
+
+		expect(
+			mockUseQueryBuilder.redirectWithQueryBuilderData,
+		).toHaveBeenCalledTimes(1);
+
+		const [
+			queryArg,
+		] = mockUseQueryBuilder.redirectWithQueryBuilderData.mock.calls[0];
+
+		expect(queryArg).toEqual({
+			...mockUseQueryBuilder.currentQuery,
+			queryType: EQueryType.PROM,
+		});
+
+		expect(mockUseQueryBuilder.redirectWithQueryBuilderData).toHaveBeenCalledWith(
+			queryArg,
+		);
+	});
+
+	it('updates the query data when switching from promql to query_builder for logs', async () => {
+		const user = userEvent.setup();
+
+		const mockCurrentQueryWithPromQL = {
+			...mockUseQueryBuilder.currentQuery,
+			queryType: EQueryType.PROM,
+			builder: {
+				queryData: [
+					{
+						dataSource: DataSource.LOGS,
+					},
+				],
+			},
+		};
+
+		useQueryBuilder.mockReturnValue({
+			...mockUseQueryBuilder,
+			currentQuery: mockCurrentQueryWithPromQL,
+		});
+
+		render(
+			<Provider store={store}>
+				<QueryClientProvider client={queryClient}>
+					<MemoryRouter>
+						<CreateAlertProvider initialAlertType={AlertTypes.LOGS_BASED_ALERT}>
+							<QuerySection />
+						</CreateAlertProvider>
+					</MemoryRouter>
+				</QueryClientProvider>
+			</Provider>,
+		);
+
+		const changeToQueryBuilderButton = screen.getByTestId(
+			'change-to-query-builder',
+		);
+		await user.click(changeToQueryBuilderButton);
+
+		expect(
+			mockUseQueryBuilder.redirectWithQueryBuilderData,
+		).toHaveBeenCalledTimes(1);
+
+		const [
+			queryArg,
+		] = mockUseQueryBuilder.redirectWithQueryBuilderData.mock.calls[0];
+
+		expect(queryArg).toEqual({
+			...mockCurrentQueryWithPromQL,
+			queryType: EQueryType.QUERY_BUILDER,
+		});
+
+		expect(mockUseQueryBuilder.redirectWithQueryBuilderData).toHaveBeenCalledWith(
+			queryArg,
+		);
+	});
+
+	it('updates the query data when switching from clickhouse_sql to query_builder for traces', async () => {
+		const user = userEvent.setup();
+
+		const mockCurrentQueryWithClickhouseSQL = {
+			...mockUseQueryBuilder.currentQuery,
+			queryType: EQueryType.CLICKHOUSE,
+			builder: {
+				queryData: [
+					{
+						dataSource: DataSource.TRACES,
+					},
+				],
+			},
+		};
+
+		useQueryBuilder.mockReturnValue({
+			...mockUseQueryBuilder,
+			currentQuery: mockCurrentQueryWithClickhouseSQL,
+		});
+
+		render(
+			<Provider store={store}>
+				<QueryClientProvider client={queryClient}>
+					<MemoryRouter>
+						<CreateAlertProvider initialAlertType={AlertTypes.TRACES_BASED_ALERT}>
+							<QuerySection />
+						</CreateAlertProvider>
+					</MemoryRouter>
+				</QueryClientProvider>
+			</Provider>,
+		);
+
+		const changeToQueryBuilderButton = screen.getByTestId(
+			'change-to-query-builder',
+		);
+		await user.click(changeToQueryBuilderButton);
+
+		expect(
+			mockUseQueryBuilder.redirectWithQueryBuilderData,
+		).toHaveBeenCalledTimes(1);
+
+		const [
+			queryArg,
+		] = mockUseQueryBuilder.redirectWithQueryBuilderData.mock.calls[0];
+
+		expect(queryArg).toEqual({
+			...mockCurrentQueryWithClickhouseSQL,
+			queryType: EQueryType.QUERY_BUILDER,
+		});
+
+		expect(mockUseQueryBuilder.redirectWithQueryBuilderData).toHaveBeenCalledWith(
+			queryArg,
+		);
+	});
 });

frontend/src/container/CreateAlertV2/context/__tests__/utils.test.tsx

@@ -0,0 +1,678 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { UniversalYAxisUnit } from 'components/YAxisUnitSelector/types';
+import { initialQueriesMap } from 'constants/queryBuilder';
+import {
+	alertDefaults,
+	anamolyAlertDefaults,
+	exceptionAlertDefaults,
+	logAlertDefaults,
+	traceAlertDefaults,
+} from 'container/CreateAlertRule/defaults';
+import dayjs from 'dayjs';
+import { AlertTypes } from 'types/api/alerts/alertTypes';
+
+import {
+	INITIAL_ADVANCED_OPTIONS_STATE,
+	INITIAL_ALERT_STATE,
+	INITIAL_ALERT_THRESHOLD_STATE,
+	INITIAL_EVALUATION_WINDOW_STATE,
+	INITIAL_NOTIFICATION_SETTINGS_STATE,
+} from '../constants';
+import {
+	AdvancedOptionsState,
+	AlertState,
+	AlertThresholdMatchType,
+	AlertThresholdOperator,
+	AlertThresholdState,
+	Algorithm,
+	EvaluationWindowState,
+	NotificationSettingsState,
+	Seasonality,
+	TimeDuration,
+} from '../types';
+import {
+	advancedOptionsReducer,
+	alertCreationReducer,
+	alertThresholdReducer,
+	buildInitialAlertDef,
+	evaluationWindowReducer,
+	getInitialAlertType,
+	getInitialAlertTypeFromURL,
+	notificationSettingsReducer,
+} from '../utils';
+
+const UNKNOWN_ACTION_TYPE = 'UNKNOWN_ACTION_TYPE';
+const TEST_RESET_TO_INITIAL_STATE = 'should reset to initial state';
+const TEST_SET_INITIAL_STATE_FROM_PAYLOAD =
+	'should set initial state from payload';
+const TEST_RETURN_STATE_FOR_UNKNOWN_ACTION =
+	'should return current state for unknown action';
+
+describe('CreateAlertV2 Context Utils', () => {
+	describe('alertCreationReducer', () => {
+		it('should set alert name', () => {
+			const result = alertCreationReducer(INITIAL_ALERT_STATE, {
+				type: 'SET_ALERT_NAME',
+				payload: 'Test Alert',
+			});
+			expect(result).toEqual({
+				...INITIAL_ALERT_STATE,
+				name: 'Test Alert',
+			});
+		});
+
+		it('should set alert labels', () => {
+			const labels = { severity: 'critical', team: 'backend' };
+			const result = alertCreationReducer(INITIAL_ALERT_STATE, {
+				type: 'SET_ALERT_LABELS',
+				payload: labels,
+			});
+			expect(result).toEqual({
+				...INITIAL_ALERT_STATE,
+				labels,
+			});
+		});
+
+		it('should set y-axis unit', () => {
+			const result = alertCreationReducer(INITIAL_ALERT_STATE, {
+				type: 'SET_Y_AXIS_UNIT',
+				payload: 'ms',
+			});
+			expect(result).toEqual({
+				...INITIAL_ALERT_STATE,
+				yAxisUnit: 'ms',
+			});
+		});
+
+		it(TEST_RESET_TO_INITIAL_STATE, () => {
+			const modifiedState: AlertState = {
+				name: 'Modified',
+				labels: { test: 'value' },
+				yAxisUnit: 'ms',
+			};
+			const result = alertCreationReducer(modifiedState, { type: 'RESET' });
+			expect(result).toEqual(INITIAL_ALERT_STATE);
+		});
+
+		it(TEST_SET_INITIAL_STATE_FROM_PAYLOAD, () => {
+			const newState: AlertState = {
+				name: 'Custom Alert',
+				labels: { env: 'production' },
+				yAxisUnit: 'bytes',
+			};
+			const result = alertCreationReducer(INITIAL_ALERT_STATE, {
+				type: 'SET_INITIAL_STATE',
+				payload: newState,
+			});
+			expect(result).toEqual(newState);
+		});
+
+		it(TEST_RETURN_STATE_FOR_UNKNOWN_ACTION, () => {
+			const result = alertCreationReducer(
+				INITIAL_ALERT_STATE,
+
+				{ type: UNKNOWN_ACTION_TYPE } as any,
+			);
+			expect(result).toEqual(INITIAL_ALERT_STATE);
+		});
+	});
+
+	describe('getInitialAlertType', () => {
+		it('should return METRICS_BASED_ALERT for metrics data source', () => {
+			const result = getInitialAlertType(initialQueriesMap.metrics);
+			expect(result).toBe(AlertTypes.METRICS_BASED_ALERT);
+		});
+
+		it('should return LOGS_BASED_ALERT for logs data source', () => {
+			const result = getInitialAlertType(initialQueriesMap.logs);
+			expect(result).toBe(AlertTypes.LOGS_BASED_ALERT);
+		});
+
+		it('should return TRACES_BASED_ALERT for traces data source', () => {
+			const result = getInitialAlertType(initialQueriesMap.traces);
+			expect(result).toBe(AlertTypes.TRACES_BASED_ALERT);
+		});
+
+		it('should return METRICS_BASED_ALERT for unknown data source', () => {
+			const queryWithUnknownDataSource = {
+				...initialQueriesMap.metrics,
+				builder: {
+					...initialQueriesMap.metrics.builder,
+					queryData: [],
+				},
+			};
+			const result = getInitialAlertType(queryWithUnknownDataSource);
+			expect(result).toBe(AlertTypes.METRICS_BASED_ALERT);
+		});
+	});
+
+	describe('buildInitialAlertDef', () => {
+		it('should return logAlertDefaults for LOGS_BASED_ALERT', () => {
+			const result = buildInitialAlertDef(AlertTypes.LOGS_BASED_ALERT);
+			expect(result).toBe(logAlertDefaults);
+		});
+
+		it('should return traceAlertDefaults for TRACES_BASED_ALERT', () => {
+			const result = buildInitialAlertDef(AlertTypes.TRACES_BASED_ALERT);
+			expect(result).toBe(traceAlertDefaults);
+		});
+
+		it('should return exceptionAlertDefaults for EXCEPTIONS_BASED_ALERT', () => {
+			const result = buildInitialAlertDef(AlertTypes.EXCEPTIONS_BASED_ALERT);
+			expect(result).toBe(exceptionAlertDefaults);
+		});
+
+		it('should return anamolyAlertDefaults for ANOMALY_BASED_ALERT', () => {
+			const result = buildInitialAlertDef(AlertTypes.ANOMALY_BASED_ALERT);
+			expect(result).toBe(anamolyAlertDefaults);
+		});
+
+		it('should return alertDefaults for METRICS_BASED_ALERT', () => {
+			const result = buildInitialAlertDef(AlertTypes.METRICS_BASED_ALERT);
+			expect(result).toBe(alertDefaults);
+		});
+
+		it('should return alertDefaults for unknown alert type', () => {
+			const result = buildInitialAlertDef('UNKNOWN' as AlertTypes);
+			expect(result).toBe(alertDefaults);
+		});
+	});
+
+	describe('getInitialAlertTypeFromURL', () => {
+		it('should return ANOMALY_BASED_ALERT when ruleType is anomaly_rule', () => {
+			const params = new URLSearchParams('?ruleType=anomaly_rule');
+			const result = getInitialAlertTypeFromURL(params, initialQueriesMap.metrics);
+			expect(result).toBe(AlertTypes.ANOMALY_BASED_ALERT);
+		});
+
+		it('should return alert type from alertType param', () => {
+			const params = new URLSearchParams('?alertType=LOGS_BASED_ALERT');
+			const result = getInitialAlertTypeFromURL(params, initialQueriesMap.metrics);
+			expect(result).toBe(AlertTypes.LOGS_BASED_ALERT);
+		});
+
+		it('should prioritize ruleType over alertType', () => {
+			const params = new URLSearchParams(
+				'?ruleType=anomaly_rule&alertType=LOGS_BASED_ALERT',
+			);
+			const result = getInitialAlertTypeFromURL(params, initialQueriesMap.metrics);
+			expect(result).toBe(AlertTypes.ANOMALY_BASED_ALERT);
+		});
+
+		it('should fall back to query data source when no URL params', () => {
+			const params = new URLSearchParams('');
+			const result = getInitialAlertTypeFromURL(params, initialQueriesMap.traces);
+			expect(result).toBe(AlertTypes.TRACES_BASED_ALERT);
+		});
+	});
+
+	describe('alertThresholdReducer', () => {
+		it('should set selected query', () => {
+			const result = alertThresholdReducer(INITIAL_ALERT_THRESHOLD_STATE, {
+				type: 'SET_SELECTED_QUERY',
+				payload: 'B',
+			});
+			expect(result).toEqual({
+				...INITIAL_ALERT_THRESHOLD_STATE,
+				selectedQuery: 'B',
+			});
+		});
+
+		it('should set operator', () => {
+			const result = alertThresholdReducer(INITIAL_ALERT_THRESHOLD_STATE, {
+				type: 'SET_OPERATOR',
+				payload: AlertThresholdOperator.IS_BELOW,
+			});
+			expect(result).toEqual({
+				...INITIAL_ALERT_THRESHOLD_STATE,
+				operator: AlertThresholdOperator.IS_BELOW,
+			});
+		});
+
+		it('should set match type', () => {
+			const result = alertThresholdReducer(INITIAL_ALERT_THRESHOLD_STATE, {
+				type: 'SET_MATCH_TYPE',
+				payload: AlertThresholdMatchType.ALL_THE_TIME,
+			});
+			expect(result).toEqual({
+				...INITIAL_ALERT_THRESHOLD_STATE,
+				matchType: AlertThresholdMatchType.ALL_THE_TIME,
+			});
+		});
+
+		it('should set thresholds', () => {
+			const newThresholds = [
+				{
+					id: '1',
+					label: 'critical',
+					thresholdValue: 100,
+					recoveryThresholdValue: 90,
+					unit: 'ms',
+					channels: ['channel1'],
+					color: '#FF0000',
+				},
+			];
+			const result = alertThresholdReducer(INITIAL_ALERT_THRESHOLD_STATE, {
+				type: 'SET_THRESHOLDS',
+				payload: newThresholds,
+			});
+			expect(result).toEqual({
+				...INITIAL_ALERT_THRESHOLD_STATE,
+				thresholds: newThresholds,
+			});
+		});
+
+		it(TEST_RESET_TO_INITIAL_STATE, () => {
+			const modifiedState: AlertThresholdState = {
+				selectedQuery: 'B',
+				operator: AlertThresholdOperator.IS_BELOW,
+				matchType: AlertThresholdMatchType.ALL_THE_TIME,
+				evaluationWindow: TimeDuration.TEN_MINUTES,
+				algorithm: Algorithm.STANDARD,
+				seasonality: Seasonality.DAILY,
+				thresholds: [],
+			};
+			const result = alertThresholdReducer(modifiedState, { type: 'RESET' });
+			expect(result).toEqual(INITIAL_ALERT_THRESHOLD_STATE);
+		});
+
+		it(TEST_SET_INITIAL_STATE_FROM_PAYLOAD, () => {
+			const newState: AlertThresholdState = {
+				selectedQuery: 'C',
+				operator: AlertThresholdOperator.IS_EQUAL_TO,
+				matchType: AlertThresholdMatchType.ON_AVERAGE,
+				evaluationWindow: TimeDuration.ONE_HOUR,
+				algorithm: Algorithm.STANDARD,
+				seasonality: Seasonality.WEEKLY,
+				thresholds: [],
+			};
+			const result = alertThresholdReducer(INITIAL_ALERT_THRESHOLD_STATE, {
+				type: 'SET_INITIAL_STATE',
+				payload: newState,
+			});
+			expect(result).toEqual(newState);
+		});
+
+		it(TEST_RETURN_STATE_FOR_UNKNOWN_ACTION, () => {
+			const result = alertThresholdReducer(
+				INITIAL_ALERT_THRESHOLD_STATE,
+
+				{ type: UNKNOWN_ACTION_TYPE } as any,
+			);
+			expect(result).toEqual(INITIAL_ALERT_THRESHOLD_STATE);
+		});
+	});
+
+	describe('advancedOptionsReducer', () => {
+		it('should set send notification if data is missing', () => {
+			const result = advancedOptionsReducer(INITIAL_ADVANCED_OPTIONS_STATE, {
+				type: 'SET_SEND_NOTIFICATION_IF_DATA_IS_MISSING',
+				payload: { toleranceLimit: 21, timeUnit: UniversalYAxisUnit.HOURS },
+			});
+			expect(result).toEqual({
+				...INITIAL_ADVANCED_OPTIONS_STATE,
+				sendNotificationIfDataIsMissing: {
+					...INITIAL_ADVANCED_OPTIONS_STATE.sendNotificationIfDataIsMissing,
+					toleranceLimit: 21,
+					timeUnit: UniversalYAxisUnit.HOURS,
+				},
+			});
+		});
+
+		it('should toggle send notification if data is missing', () => {
+			const result = advancedOptionsReducer(INITIAL_ADVANCED_OPTIONS_STATE, {
+				type: 'TOGGLE_SEND_NOTIFICATION_IF_DATA_IS_MISSING',
+				payload: true,
+			});
+			expect(result).toEqual({
+				...INITIAL_ADVANCED_OPTIONS_STATE,
+				sendNotificationIfDataIsMissing: {
+					...INITIAL_ADVANCED_OPTIONS_STATE.sendNotificationIfDataIsMissing,
+					enabled: true,
+				},
+			});
+		});
+
+		it('should set enforce minimum datapoints', () => {
+			const result = advancedOptionsReducer(INITIAL_ADVANCED_OPTIONS_STATE, {
+				type: 'SET_ENFORCE_MINIMUM_DATAPOINTS',
+				payload: { minimumDatapoints: 10 },
+			});
+			expect(result).toEqual({
+				...INITIAL_ADVANCED_OPTIONS_STATE,
+				enforceMinimumDatapoints: {
+					...INITIAL_ADVANCED_OPTIONS_STATE.enforceMinimumDatapoints,
+					minimumDatapoints: 10,
+				},
+			});
+		});
+
+		it('should toggle enforce minimum datapoints', () => {
+			const result = advancedOptionsReducer(INITIAL_ADVANCED_OPTIONS_STATE, {
+				type: 'TOGGLE_ENFORCE_MINIMUM_DATAPOINTS',
+				payload: true,
+			});
+			expect(result).toEqual({
+				...INITIAL_ADVANCED_OPTIONS_STATE,
+				enforceMinimumDatapoints: {
+					...INITIAL_ADVANCED_OPTIONS_STATE.enforceMinimumDatapoints,
+					enabled: true,
+				},
+			});
+		});
+
+		it('should set delay evaluation', () => {
+			const result = advancedOptionsReducer(INITIAL_ADVANCED_OPTIONS_STATE, {
+				type: 'SET_DELAY_EVALUATION',
+				payload: { delay: 10, timeUnit: UniversalYAxisUnit.HOURS },
+			});
+			expect(result).toEqual({
+				...INITIAL_ADVANCED_OPTIONS_STATE,
+				delayEvaluation: { delay: 10, timeUnit: UniversalYAxisUnit.HOURS },
+			});
+		});
+
+		it('should set evaluation cadence', () => {
+			const newCadence = {
+				default: { value: 5, timeUnit: UniversalYAxisUnit.HOURS },
+				custom: {
+					repeatEvery: 'week',
+					startAt: '12:00:00',
+					timezone: 'America/New_York',
+					occurence: ['Monday', 'Friday'],
+				},
+				rrule: { date: dayjs(), startAt: '10:00:00', rrule: 'test-rrule' },
+			};
+			const result = advancedOptionsReducer(INITIAL_ADVANCED_OPTIONS_STATE, {
+				type: 'SET_EVALUATION_CADENCE',
+				payload: newCadence,
+			});
+			expect(result).toEqual({
+				...INITIAL_ADVANCED_OPTIONS_STATE,
+				evaluationCadence: {
+					...INITIAL_ADVANCED_OPTIONS_STATE.evaluationCadence,
+					...newCadence,
+				},
+			});
+		});
+
+		it('should set evaluation cadence mode', () => {
+			const result = advancedOptionsReducer(INITIAL_ADVANCED_OPTIONS_STATE, {
+				type: 'SET_EVALUATION_CADENCE_MODE',
+				payload: 'custom',
+			});
+			expect(result).toEqual({
+				...INITIAL_ADVANCED_OPTIONS_STATE,
+				evaluationCadence: {
+					...INITIAL_ADVANCED_OPTIONS_STATE.evaluationCadence,
+					mode: 'custom',
+				},
+			});
+		});
+
+		it(TEST_RESET_TO_INITIAL_STATE, () => {
+			const modifiedState: AdvancedOptionsState = {
+				...INITIAL_ADVANCED_OPTIONS_STATE,
+				delayEvaluation: { delay: 10, timeUnit: UniversalYAxisUnit.HOURS },
+			};
+			const result = advancedOptionsReducer(modifiedState, { type: 'RESET' });
+			expect(result).toEqual(INITIAL_ADVANCED_OPTIONS_STATE);
+		});
+
+		it(TEST_SET_INITIAL_STATE_FROM_PAYLOAD, () => {
+			const newState: AdvancedOptionsState = {
+				...INITIAL_ADVANCED_OPTIONS_STATE,
+				sendNotificationIfDataIsMissing: {
+					toleranceLimit: 45,
+					timeUnit: UniversalYAxisUnit.SECONDS,
+					enabled: true,
+				},
+			};
+			const result = advancedOptionsReducer(INITIAL_ADVANCED_OPTIONS_STATE, {
+				type: 'SET_INITIAL_STATE',
+				payload: newState,
+			});
+			expect(result).toEqual(newState);
+		});
+
+		it(TEST_RETURN_STATE_FOR_UNKNOWN_ACTION, () => {
+			const result = advancedOptionsReducer(
+				INITIAL_ADVANCED_OPTIONS_STATE,
+
+				{ type: UNKNOWN_ACTION_TYPE } as any,
+			);
+			expect(result).toEqual(INITIAL_ADVANCED_OPTIONS_STATE);
+		});
+	});
+
+	describe('evaluationWindowReducer', () => {
+		it('should set window type to rolling and reset timeframe', () => {
+			const modifiedState: EvaluationWindowState = {
+				...INITIAL_EVALUATION_WINDOW_STATE,
+				windowType: 'cumulative',
+				timeframe: 'currentHour',
+			};
+			const result = evaluationWindowReducer(modifiedState, {
+				type: 'SET_WINDOW_TYPE',
+				payload: 'rolling',
+			});
+			expect(result).toEqual({
+				windowType: 'rolling',
+				timeframe: INITIAL_EVALUATION_WINDOW_STATE.timeframe,
+				startingAt: INITIAL_EVALUATION_WINDOW_STATE.startingAt,
+			});
+		});
+
+		it('should set window type to cumulative and set timeframe to currentHour', () => {
+			const result = evaluationWindowReducer(INITIAL_EVALUATION_WINDOW_STATE, {
+				type: 'SET_WINDOW_TYPE',
+				payload: 'cumulative',
+			});
+			expect(result).toEqual({
+				windowType: 'cumulative',
+				timeframe: 'currentHour',
+				startingAt: INITIAL_EVALUATION_WINDOW_STATE.startingAt,
+			});
+		});
+
+		it('should set timeframe', () => {
+			const result = evaluationWindowReducer(INITIAL_EVALUATION_WINDOW_STATE, {
+				type: 'SET_TIMEFRAME',
+				payload: '10m0s',
+			});
+			expect(result).toEqual({
+				...INITIAL_EVALUATION_WINDOW_STATE,
+				timeframe: '10m0s',
+			});
+		});
+
+		it('should set starting at', () => {
+			const newStartingAt = {
+				time: '14:30:00',
+				number: '5',
+				timezone: 'Europe/London',
+				unit: UniversalYAxisUnit.HOURS,
+			};
+			const result = evaluationWindowReducer(INITIAL_EVALUATION_WINDOW_STATE, {
+				type: 'SET_STARTING_AT',
+				payload: newStartingAt,
+			});
+			expect(result).toEqual({
+				...INITIAL_EVALUATION_WINDOW_STATE,
+				startingAt: newStartingAt,
+			});
+		});
+
+		it(TEST_RESET_TO_INITIAL_STATE, () => {
+			const modifiedState: EvaluationWindowState = {
+				windowType: 'cumulative',
+				timeframe: 'currentHour',
+				startingAt: {
+					time: '12:00:00',
+					number: '2',
+					timezone: 'America/New_York',
+					unit: UniversalYAxisUnit.HOURS,
+				},
+			};
+			const result = evaluationWindowReducer(modifiedState, { type: 'RESET' });
+			expect(result).toEqual(INITIAL_EVALUATION_WINDOW_STATE);
+		});
+
+		it(TEST_SET_INITIAL_STATE_FROM_PAYLOAD, () => {
+			const newState: EvaluationWindowState = {
+				windowType: 'cumulative',
+				timeframe: 'currentDay',
+				startingAt: {
+					time: '09:00:00',
+					number: '3',
+					timezone: 'Asia/Tokyo',
+					unit: UniversalYAxisUnit.HOURS,
+				},
+			};
+			const result = evaluationWindowReducer(INITIAL_EVALUATION_WINDOW_STATE, {
+				type: 'SET_INITIAL_STATE',
+				payload: newState,
+			});
+			expect(result).toEqual(newState);
+		});
+
+		it(TEST_RETURN_STATE_FOR_UNKNOWN_ACTION, () => {
+			const result = evaluationWindowReducer(
+				INITIAL_EVALUATION_WINDOW_STATE,
+
+				{ type: UNKNOWN_ACTION_TYPE } as any,
+			);
+			expect(result).toEqual(INITIAL_EVALUATION_WINDOW_STATE);
+		});
+	});
+
+	describe('notificationSettingsReducer', () => {
+		it('should set multiple notifications', () => {
+			const notifications = ['channel1', 'channel2', 'channel3'];
+			const result = notificationSettingsReducer(
+				INITIAL_NOTIFICATION_SETTINGS_STATE,
+				{
+					type: 'SET_MULTIPLE_NOTIFICATIONS',
+					payload: notifications,
+				},
+			);
+			expect(result).toEqual({
+				...INITIAL_NOTIFICATION_SETTINGS_STATE,
+				multipleNotifications: notifications,
+			});
+		});
+
+		it('should set multiple notifications to null', () => {
+			const modifiedState = {
+				...INITIAL_NOTIFICATION_SETTINGS_STATE,
+				multipleNotifications: ['channel1', 'channel2'],
+			};
+			const result = notificationSettingsReducer(modifiedState, {
+				type: 'SET_MULTIPLE_NOTIFICATIONS',
+				payload: null,
+			});
+			expect(result).toEqual({
+				...modifiedState,
+				multipleNotifications: null,
+			});
+		});
+
+		it('should set re-notification', () => {
+			const reNotification = {
+				enabled: true,
+				value: 60,
+				unit: UniversalYAxisUnit.HOURS,
+				conditions: ['firing' as const, 'nodata' as const],
+			};
+			const result = notificationSettingsReducer(
+				INITIAL_NOTIFICATION_SETTINGS_STATE,
+				{
+					type: 'SET_RE_NOTIFICATION',
+					payload: reNotification,
+				},
+			);
+			expect(result).toEqual({
+				...INITIAL_NOTIFICATION_SETTINGS_STATE,
+				reNotification,
+			});
+		});
+
+		it('should set description', () => {
+			const description = 'Custom alert description with {{$value}}';
+			const result = notificationSettingsReducer(
+				INITIAL_NOTIFICATION_SETTINGS_STATE,
+				{
+					type: 'SET_DESCRIPTION',
+					payload: description,
+				},
+			);
+			expect(result).toEqual({
+				...INITIAL_NOTIFICATION_SETTINGS_STATE,
+				description,
+			});
+		});
+
+		it('should set routing policies', () => {
+			const result = notificationSettingsReducer(
+				INITIAL_NOTIFICATION_SETTINGS_STATE,
+				{
+					type: 'SET_ROUTING_POLICIES',
+					payload: true,
+				},
+			);
+			expect(result).toEqual({
+				...INITIAL_NOTIFICATION_SETTINGS_STATE,
+				routingPolicies: true,
+			});
+		});
+
+		it(TEST_RESET_TO_INITIAL_STATE, () => {
+			const modifiedState: NotificationSettingsState = {
+				multipleNotifications: ['channel1'],
+				reNotification: {
+					enabled: true,
+					value: 120,
+					unit: UniversalYAxisUnit.HOURS,
+					conditions: ['firing'],
+				},
+				description: 'Modified description',
+				routingPolicies: true,
+			};
+			const result = notificationSettingsReducer(modifiedState, {
+				type: 'RESET',
+			});
+			expect(result).toEqual(INITIAL_NOTIFICATION_SETTINGS_STATE);
+		});
+
+		it(TEST_SET_INITIAL_STATE_FROM_PAYLOAD, () => {
+			const newState: NotificationSettingsState = {
+				multipleNotifications: ['channel4', 'channel5'],
+				reNotification: {
+					enabled: true,
+					value: 90,
+					unit: UniversalYAxisUnit.MINUTES,
+					conditions: ['nodata'],
+				},
+				description: 'New description',
+				routingPolicies: true,
+			};
+			const result = notificationSettingsReducer(
+				INITIAL_NOTIFICATION_SETTINGS_STATE,
+				{
+					type: 'SET_INITIAL_STATE',
+					payload: newState,
+				},
+			);
+			expect(result).toEqual(newState);
+		});
+
+		it(TEST_RETURN_STATE_FOR_UNKNOWN_ACTION, () => {
+			const result = notificationSettingsReducer(
+				INITIAL_NOTIFICATION_SETTINGS_STATE,
+
+				{ type: UNKNOWN_ACTION_TYPE } as any,
+			);
+			expect(result).toEqual(INITIAL_NOTIFICATION_SETTINGS_STATE);
+		});
+	});
+});

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

@@ -51,7 +51,13 @@ export const useCreateAlertState = (): ICreateAlertContextProps => {
 export function CreateAlertProvider(
 	props: ICreateAlertProviderProps,
 ): JSX.Element {
-	const { children, initialAlertState, isEditMode, ruleId } = props;
+	const {
+		children,
+		initialAlertState,
+		isEditMode,
+		ruleId,
+		initialAlertType,
+	} = props;
 
 	const [alertState, setAlertState] = useReducer(
 		alertCreationReducer,
@@ -62,9 +68,12 @@ export function CreateAlertProvider(
 	const location = useLocation();
 	const queryParams = new URLSearchParams(location.search);
 
-	const [alertType, setAlertType] = useState<AlertTypes>(() =>
-		getInitialAlertTypeFromURL(queryParams, currentQuery),
-	);
+	const [alertType, setAlertType] = useState<AlertTypes>(() => {
+		if (isEditMode) {
+			return initialAlertType;
+		}
+		return getInitialAlertTypeFromURL(queryParams, currentQuery);
+	});
 
 	const handleAlertTypeChange = useCallback(
 		(value: AlertTypes): void => {

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

@@ -62,7 +62,7 @@ export const alertCreationReducer = (
 
 export function getInitialAlertType(currentQuery: Query): AlertTypes {
 	const dataSource =
-		currentQuery.builder.queryData[0].dataSource || DataSource.METRICS;
+		currentQuery.builder.queryData?.[0]?.dataSource || DataSource.METRICS;
 	switch (dataSource) {
 		case DataSource.METRICS:
 			return AlertTypes.METRICS_BASED_ALERT;

frontend/src/container/EditAlertV2/utils.tsx

@@ -0,0 +1,16 @@
+import { ALERTS_DATA_SOURCE_MAP } from 'constants/alerts';
+import { initialQueryBuilderFormValuesMap } from 'constants/queryBuilder';
+import { AlertTypes } from 'types/api/alerts/alertTypes';
+import { Query } from 'types/api/queryBuilder/queryBuilderData';
+
+export function sanitizeDefaultAlertQuery(
+	query: Query,
+	alertType: AlertTypes,
+): Query {
+	// If there are no queries, add a default one based on the alert type
+	if (query.builder.queryData.length === 0) {
+		const dataSource = ALERTS_DATA_SOURCE_MAP[alertType];
+		query.builder.queryData.push(initialQueryBuilderFormValuesMap[dataSource]);
+	}
+	return query;
+}

frontend/src/container/InfraMonitoringK8s/EntityDetailsUtils/EntityEvents/__tests__/EntityEvents.test.tsx

@@ -23,6 +23,7 @@ jest.mock('container/TopNav/DateTimeSelectionV2', () => ({
 
 const mockUseQuery = jest.fn();
 jest.mock('react-query', () => ({
+	...jest.requireActual('react-query'),
 	useQuery: (queryKey: any, queryFn: any, options: any): any =>
 		mockUseQuery(queryKey, queryFn, options),
 }));

frontend/src/container/InfraMonitoringK8s/EntityDetailsUtils/EntityMetrics/__tests__/EntityMetrics.test.tsx

@@ -52,6 +52,7 @@ jest.mock('container/InfraMonitoringK8s/commonUtils', () => ({
 const mockUseQueries = jest.fn();
 const mockUseQuery = jest.fn();
 jest.mock('react-query', () => ({
+	...jest.requireActual('react-query'),
 	useQueries: (queryConfigs: any[]): any[] => mockUseQueries(queryConfigs),
 	useQuery: (config: any): any => mockUseQuery(config),
 }));

frontend/src/container/InfraMonitoringK8s/EntityDetailsUtils/EntityTraces/__tests__/EntityTraces.test.tsx

@@ -22,6 +22,7 @@ jest.mock('container/TopNav/DateTimeSelectionV2', () => ({
 
 const mockUseQuery = jest.fn();
 jest.mock('react-query', () => ({
+	...jest.requireActual('react-query'),
 	useQuery: (queryKey: any, queryFn: any, options: any): any =>
 		mockUseQuery(queryKey, queryFn, options),
 }));

frontend/src/container/ListAlertRules/ListAlert.tsx

@@ -23,6 +23,7 @@ import LabelColumn from 'components/TableRenderer/LabelColumn';
 import TextToolTip from 'components/TextToolTip';
 import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
+import { sanitizeDefaultAlertQuery } from 'container/EditAlertV2/utils';
 import useSortableTable from 'hooks/ResizeTable/useSortableTable';
 import useComponentPermission from 'hooks/useComponentPermission';
 import useDebouncedFn from 'hooks/useDebouncedFunction';
@@ -36,6 +37,7 @@ import { useCallback, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { UseQueryResult } from 'react-query';
 import { ErrorResponse, SuccessResponse } from 'types/api';
+import { AlertTypes } from 'types/api/alerts/alertTypes';
 import { GettableAlert } from 'types/api/alerts/get';
 
 import DeleteAlert from './DeleteAlert';
@@ -141,7 +143,10 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 	];
 
 	const onEditHandler = (record: GettableAlert, openInNewTab: boolean): void => {
-		const compositeQuery = mapQueryDataFromApi(record.condition.compositeQuery);
+		const compositeQuery = sanitizeDefaultAlertQuery(
+			mapQueryDataFromApi(record.condition.compositeQuery),
+			record.alertType as AlertTypes,
+		);
 		params.set(
 			QueryParams.compositeQuery,
 			encodeURIComponent(JSON.stringify(compositeQuery)),

frontend/src/container/Login/__tests__/Login.test.tsx

@@ -1,118 +1,830 @@
-import Login from 'container/Login';
-import { act, fireEvent, render, screen, waitFor } from 'tests/test-utils';
+/* eslint-disable sonarjs/no-identical-functions */
+import ROUTES from 'constants/routes';
+import history from 'lib/history';
+import { rest, server } from 'mocks-server/server';
+import { render, screen, userEvent, waitFor } from 'tests/test-utils';
+import { ErrorV2 } from 'types/api';
+import { Info } from 'types/api/v1/version/get';
+import { SessionsContext } from 'types/api/v2/sessions/context/get';
+import { Token } from 'types/api/v2/sessions/email_password/post';
 
-const errorNotification = jest.fn();
-jest.mock('hooks/useNotifications', () => ({
+import Login from '../index';
+
+const VERSION_ENDPOINT = '*/api/v1/version';
+const SESSIONS_CONTEXT_ENDPOINT = '*/api/v2/sessions/context';
+const CALLBACK_AUTHN_ORG = 'callback_authn_org';
+const CALLBACK_AUTHN_URL = 'https://sso.example.com/auth';
+const PASSWORD_AUTHN_ORG = 'password_authn_org';
+const PASSWORD_AUTHN_EMAIL = 'jest.test@signoz.io';
+
+jest.mock('lib/history', () => ({
 	__esModule: true,
-	useNotifications: jest.fn(() => ({
-		notifications: {
-			error: errorNotification,
+	default: {
+		push: jest.fn(),
+		location: {
+			search: '',
 		},
-	})),
+	},
 }));
 
-describe('Login Flow', () => {
-	test('Login form is rendered correctly', async () => {
-		render(<Login ssoerror="" jwt="" refreshjwt="" userId="" withPassword="" />);
+const mockHistoryPush = history.push as jest.MockedFunction<
+	typeof history.push
+>;
 
-		// Check for the main description
-		expect(
-			screen.getByText(
-				'Sign in to monitor, trace, and troubleshoot your applications effortlessly.',
-			),
-		).toBeInTheDocument();
+// Mock data
+const mockVersionSetupCompleted: Info = {
+	setupCompleted: true,
+	ee: 'Y',
+	version: '0.25.0',
+};
 
-		// Email input
-		const emailInput = screen.getByTestId('email');
-		expect(emailInput).toBeInTheDocument();
-		expect(emailInput).toHaveAttribute('type', 'email');
+const mockVersionSetupIncomplete: Info = {
+	setupCompleted: false,
+	ee: 'Y',
+	version: '0.25.0',
+};
 
-		// Next button
-		const nextButton = screen.getByRole('button', { name: /next/i });
-		expect(nextButton).toBeInTheDocument();
+const mockSingleOrgPasswordAuth: SessionsContext = {
+	exists: true,
+	orgs: [
+		{
+			id: 'org-1',
+			name: 'Test Organization',
+			authNSupport: {
+				password: [{ provider: 'email_password' }],
+				callback: [],
+			},
+		},
+	],
+};
 
-		// No account prompt (default: canSelfRegister is false)
-		expect(
-			screen.getByText(
-				"Don't have an account? Contact your admin to send you an invite link.",
-			),
-		).toBeInTheDocument();
-	});
+const mockSingleOrgCallbackAuth: SessionsContext = {
+	exists: true,
+	orgs: [
+		{
+			id: 'org-1',
+			name: 'Test Organization',
+			authNSupport: {
+				password: [],
+				callback: [{ provider: 'google', url: CALLBACK_AUTHN_URL }],
+			},
+		},
+	],
+};
 
-	test('Display error if email is not provided', async () => {
-		render(<Login ssoerror="" jwt="" refreshjwt="" userId="" withPassword="" />);
+const mockMultiOrgMixedAuth: SessionsContext = {
+	exists: true,
+	orgs: [
+		{
+			id: 'org-1',
+			name: PASSWORD_AUTHN_ORG,
+			authNSupport: {
+				password: [{ provider: 'email_password' }],
+				callback: [],
+			},
+		},
+		{
+			id: 'org-2',
+			name: CALLBACK_AUTHN_ORG,
+			authNSupport: {
+				password: [],
+				callback: [{ provider: 'google', url: CALLBACK_AUTHN_URL }],
+			},
+		},
+	],
+};
 
-		const nextButton = screen.getByRole('button', { name: /next/i });
-		fireEvent.click(nextButton);
+const mockOrgWithWarning: SessionsContext = {
+	exists: true,
+	orgs: [
+		{
+			id: 'org-1',
+			name: 'Warning Organization',
+			authNSupport: {
+				password: [{ provider: 'email_password' }],
+				callback: [],
+			},
+			warning: {
+				code: 'ORG_WARNING',
+				message: 'Organization has limited access',
+				url: 'https://example.com/warning',
+				errors: [{ message: 'Contact admin for full access' }],
+			} as ErrorV2,
+		},
+	],
+};
 
-		await waitFor(() =>
-			expect(errorNotification).toHaveBeenCalledWith({
-				message: 'Please enter a valid email address',
-			}),
-		);
-	});
+const mockEmailPasswordResponse: Token = {
+	accessToken: 'mock-access-token',
+	refreshToken: 'mock-refresh-token',
+};
 
-	test('Display error if invalid email is provided and next clicked', async () => {
-		render(<Login ssoerror="" jwt="" refreshjwt="" userId="" withPassword="" />);
+describe('Login Component', () => {
+	beforeEach(() => {
+		jest.clearAllMocks();
 
-		const emailInput = screen.getByTestId('email');
-		fireEvent.change(emailInput, {
-			target: { value: 'failEmail@signoz.io' },
-		});
-
-		const nextButton = screen.getByRole('button', { name: /next/i });
-		fireEvent.click(nextButton);
-
-		await waitFor(() =>
-			expect(errorNotification).toHaveBeenCalledWith({
-				message:
-					'Invalid configuration detected, please contact your administrator',
-			}),
-		);
-	});
-
-	test('providing shaheer@signoz.io as email and pressing next, should make the Login with SSO button visible', async () => {
-		render(<Login ssoerror="" jwt="" refreshjwt="" userId="" withPassword="" />);
-		act(() => {
-			fireEvent.change(screen.getByTestId('email'), {
-				target: { value: 'shaheer@signoz.io' },
-			});
-			fireEvent.click(screen.getByTestId('initiate_login'));
-		});
-
-		await waitFor(() => {
-			expect(screen.getByText(/login with sso/i)).toBeInTheDocument();
-		});
-	});
-
-	test('Display email, password, forgot password if password=Y', () => {
-		render(<Login ssoerror="" jwt="" refreshjwt="" userId="" withPassword="Y" />);
-
-		const emailInput = screen.getByTestId('email');
-		expect(emailInput).toBeInTheDocument();
-
-		const passwordInput = screen.getByTestId('password');
-		expect(passwordInput).toBeInTheDocument();
-
-		const forgotPasswordLink = screen.getByText('Forgot password?');
-		expect(forgotPasswordLink).toBeInTheDocument();
-	});
-
-	test('Display tooltip with correct message if forgot password is hovered while password=Y', async () => {
-		render(<Login ssoerror="" jwt="" refreshjwt="" userId="" withPassword="Y" />);
-		const forgotPasswordLink = screen.getByText('Forgot password?');
-
-		act(() => {
-			fireEvent.mouseOver(forgotPasswordLink);
-		});
-
-		await waitFor(() => {
-			// Tooltip text is static in the new UI
-			expect(
-				screen.getByText(
-					'Ask your admin to reset your password and send you a new invite link',
+		server.use(
+			rest.get(VERSION_ENDPOINT, (_, res, ctx) =>
+				res(
+					ctx.status(200),
+					ctx.json({ data: mockVersionSetupCompleted, status: 'success' }),
 				),
+			),
+		);
+	});
+
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	describe('Initial Render', () => {
+		it('renders login form with email input and next button', () => {
+			const { getByTestId, getByPlaceholderText } = render(<Login />);
+
+			expect(
+				screen.getByText(/sign in to monitor, trace, and troubleshoot/i),
 			).toBeInTheDocument();
+			expect(getByTestId('email')).toBeInTheDocument();
+			expect(getByTestId('initiate_login')).toBeInTheDocument();
+			expect(getByPlaceholderText('name@yourcompany.com')).toBeInTheDocument();
+		});
+
+		it('shows loading state when version data is being fetched', () => {
+			server.use(
+				rest.get(VERSION_ENDPOINT, (_, res, ctx) =>
+					res(
+						ctx.delay(100),
+						ctx.status(200),
+						ctx.json({ data: mockVersionSetupCompleted, status: 'success' }),
+					),
+				),
+			);
+
+			const { getByTestId } = render(<Login />);
+
+			expect(getByTestId('initiate_login')).toBeDisabled();
+		});
+	});
+
+	describe('Setup Check', () => {
+		it('redirects to signup when setup is not completed', async () => {
+			server.use(
+				rest.get(VERSION_ENDPOINT, (_, res, ctx) =>
+					res(
+						ctx.status(200),
+						ctx.json({ data: mockVersionSetupIncomplete, status: 'success' }),
+					),
+				),
+			);
+
+			render(<Login />);
+
+			await waitFor(() => {
+				expect(mockHistoryPush).toHaveBeenCalledWith(ROUTES.SIGN_UP);
+			});
+		});
+
+		it('stays on login page when setup is completed', async () => {
+			render(<Login />);
+
+			await waitFor(() => {
+				expect(mockHistoryPush).not.toHaveBeenCalled();
+			});
+		});
+
+		it('handles version API error gracefully', async () => {
+			server.use(
+				rest.get(VERSION_ENDPOINT, (req, res, ctx) =>
+					res(ctx.status(500), ctx.json({ error: 'Server error' })),
+				),
+			);
+
+			render(<Login />);
+
+			await waitFor(() => {
+				expect(mockHistoryPush).not.toHaveBeenCalled();
+			});
+		});
+	});
+
+	describe('Session Context Fetching', () => {
+		it('fetches session context on next button click and enables password', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (_, res, ctx) =>
+					res(
+						ctx.status(200),
+						ctx.json({ status: 'success', data: mockSingleOrgPasswordAuth }),
+					),
+				),
+			);
+
+			const { getByTestId } = render(<Login />);
+
+			const emailInput = getByTestId('email');
+			const nextButton = getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			await waitFor(() => {
+				expect(getByTestId('password')).toBeInTheDocument();
+			});
+		});
+
+		it('handles session context API errors', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (_, res, ctx) =>
+					res(
+						ctx.status(500),
+						ctx.json({
+							error: {
+								code: 'internal_server',
+								message: 'couldnt fetch the sessions context',
+								url: '',
+							},
+						}),
+					),
+				),
+			);
+
+			const { getByTestId, getByText } = render(<Login />);
+
+			const emailInput = getByTestId('email');
+			const nextButton = getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			await waitFor(() => {
+				expect(getByText('couldnt fetch the sessions context')).toBeInTheDocument();
+			});
+		});
+
+		it('auto-selects organization when only one exists', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (req, res, ctx) =>
+					res(
+						ctx.status(200),
+						ctx.json({ status: 'success', data: mockSingleOrgPasswordAuth }),
+					),
+				),
+			);
+
+			const { getByTestId } = render(<Login />);
+
+			const emailInput = getByTestId('email');
+			const nextButton = getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			await waitFor(() => {
+				// Should show password field directly (no org selection needed)
+				expect(getByTestId('password')).toBeInTheDocument();
+				expect(screen.queryByText(/organization name/i)).not.toBeInTheDocument();
+			});
+		});
+	});
+
+	describe('Organization Selection', () => {
+		it('shows organization dropdown when multiple orgs exist', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (_, res, ctx) =>
+					res(
+						ctx.status(200),
+						ctx.json({ status: 'success', data: mockMultiOrgMixedAuth }),
+					),
+				),
+			);
+
+			const { getByTestId, getByText } = render(<Login />);
+
+			const emailInput = getByTestId('email');
+			const nextButton = getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			await waitFor(() => {
+				expect(getByText('Organization Name')).toBeInTheDocument();
+				expect(screen.getByRole('combobox')).toBeInTheDocument();
+			});
+
+			// Click on the dropdown to reveal the options
+			await user.click(screen.getByRole('combobox'));
+
+			await waitFor(() => {
+				expect(screen.getByText(PASSWORD_AUTHN_ORG)).toBeInTheDocument();
+				expect(screen.getByText(CALLBACK_AUTHN_ORG)).toBeInTheDocument();
+			});
+		});
+
+		it('updates selected organization on dropdown change', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (req, res, ctx) =>
+					res(ctx.status(200), ctx.json({ data: mockMultiOrgMixedAuth })),
+				),
+			);
+
+			render(<Login />);
+
+			const emailInput = screen.getByTestId('email');
+			const nextButton = screen.getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			await waitFor(() => {
+				expect(screen.getByRole('combobox')).toBeInTheDocument();
+			});
+
+			// Select CALLBACK_AUTHN_ORG
+			await user.click(screen.getByRole('combobox'));
+			await user.click(screen.getByText(CALLBACK_AUTHN_ORG));
+
+			await waitFor(() => {
+				expect(
+					screen.getByRole('button', { name: /login with callback/i }),
+				).toBeInTheDocument();
+			});
+		});
+	});
+
+	describe('Password Authentication', () => {
+		it('shows password field when password auth is supported', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (_, res, ctx) =>
+					res(
+						ctx.status(200),
+						ctx.json({ status: 'success', data: mockSingleOrgPasswordAuth }),
+					),
+				),
+			);
+
+			const { getByTestId, getByText } = render(<Login />);
+
+			const emailInput = getByTestId('email');
+			const nextButton = getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			await waitFor(() => {
+				expect(getByTestId('password')).toBeInTheDocument();
+				expect(getByText(/forgot password/i)).toBeInTheDocument();
+				expect(getByTestId('password_authn_submit')).toBeInTheDocument();
+			});
+		});
+
+		it('enables password auth when URL parameter password=Y', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (_, res, ctx) =>
+					res(
+						ctx.status(200),
+						ctx.json({ status: 'success', data: mockSingleOrgCallbackAuth }),
+					),
+				),
+			);
+
+			const { getByTestId } = render(<Login />, undefined, {
+				initialRoute: '/login?password=Y',
+			});
+
+			const emailInput = getByTestId('email');
+			const nextButton = getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			await waitFor(() => {
+				// Should show password field even for SSO org due to password=Y override
+				expect(getByTestId('password')).toBeInTheDocument();
+			});
+		});
+	});
+
+	describe('Callback Authentication', () => {
+		it('shows callback login button when callback auth is supported', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (_, res, ctx) =>
+					res(
+						ctx.status(200),
+						ctx.json({ status: 'success', data: mockSingleOrgCallbackAuth }),
+					),
+				),
+			);
+
+			const { getByTestId, queryByTestId } = render(<Login />);
+
+			const emailInput = getByTestId('email');
+			const nextButton = getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			await waitFor(() => {
+				expect(getByTestId('callback_authn_submit')).toBeInTheDocument();
+				expect(queryByTestId('password')).not.toBeInTheDocument();
+			});
+		});
+
+		it('redirects to callback URL on button click', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			// Mock window.location.href
+			const mockLocation = {
+				href: 'http://localhost/',
+			};
+			Object.defineProperty(window, 'location', {
+				value: mockLocation,
+				writable: true,
+			});
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (_, res, ctx) =>
+					res(
+						ctx.status(200),
+						ctx.json({ status: 'success', data: mockSingleOrgCallbackAuth }),
+					),
+				),
+			);
+
+			const { getByTestId, queryByTestId } = render(<Login />);
+
+			const emailInput = getByTestId('email');
+			const nextButton = getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			await waitFor(() => {
+				expect(getByTestId('callback_authn_submit')).toBeInTheDocument();
+				expect(queryByTestId('password')).not.toBeInTheDocument();
+			});
+
+			const callbackButton = getByTestId('callback_authn_submit');
+			await user.click(callbackButton);
+
+			// Check that window.location.href was set to the callback URL
+			await waitFor(() => {
+				expect(window.location.href).toBe(CALLBACK_AUTHN_URL);
+			});
+		});
+	});
+
+	describe('Password Authentication Execution', () => {
+		it('calls email/password API with correct parameters', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (_, res, ctx) =>
+					res(
+						ctx.status(200),
+						ctx.json({ status: 'success', data: mockSingleOrgPasswordAuth }),
+					),
+				),
+				rest.post('*/api/v2/sessions/email_password', async (_, res, ctx) =>
+					res(
+						ctx.status(200),
+						ctx.json({ status: 'success', data: mockEmailPasswordResponse }),
+					),
+				),
+			);
+
+			const { getByTestId } = render(<Login />);
+
+			const emailInput = getByTestId('email');
+			const nextButton = getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			await waitFor(() => {
+				expect(getByTestId('password')).toBeInTheDocument();
+			});
+
+			const passwordInput = getByTestId('password');
+			const loginButton = getByTestId('password_authn_submit');
+
+			await user.type(passwordInput, 'testpassword');
+			await user.click(loginButton);
+
+			// do not test for the request paramters here. Reference: https://mswjs.io/docs/best-practices/avoid-request-assertions
+			// rather test for the effects of the request
+			await waitFor(() => {
+				expect(localStorage.getItem('AUTH_TOKEN')).toBe('mock-access-token');
+			});
+		});
+
+		it('shows error modal on authentication failure', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (_, res, ctx) =>
+					res(
+						ctx.status(200),
+						ctx.json({ status: 'success', data: mockSingleOrgPasswordAuth }),
+					),
+				),
+				rest.post('*/api/v2/sessions/email_password', (_, res, ctx) =>
+					res(
+						ctx.status(401),
+						ctx.json({
+							error: {
+								code: 'invalid_input',
+								message: 'invalid password',
+								url: '',
+							},
+						}),
+					),
+				),
+			);
+
+			const { getByTestId, getByText } = render(<Login />);
+
+			const emailInput = getByTestId('email');
+			const nextButton = getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			await waitFor(() => {
+				expect(getByTestId('password')).toBeInTheDocument();
+			});
+
+			const passwordInput = getByTestId('password');
+			const loginButton = getByTestId('password_authn_submit');
+
+			await user.type(passwordInput, 'wrongpassword');
+			await user.click(loginButton);
+
+			await waitFor(() => {
+				expect(getByText('invalid password')).toBeInTheDocument();
+			});
+		});
+	});
+
+	describe('URL Parameter Handling', () => {
+		it('calls afterLogin when accessToken and refreshToken are in URL', async () => {
+			render(<Login />, undefined, {
+				initialRoute: '/login?accessToken=test-token&refreshToken=test-refresh',
+			});
+
+			await waitFor(() => {
+				expect(localStorage.getItem('AUTH_TOKEN')).toBe('test-token');
+				expect(localStorage.getItem('REFRESH_AUTH_TOKEN')).toBe('test-refresh');
+			});
+		});
+
+		it('shows error modal when callbackauthnerr parameter exists', async () => {
+			const { getByText } = render(<Login />, undefined, {
+				initialRoute:
+					'/login?callbackauthnerr=true&code=AUTH_ERROR&message=Authentication failed&url=https://example.com/error&errors=[{"message":"Invalid token"}]',
+			});
+
+			await waitFor(() => {
+				expect(getByText('AUTH_ERROR')).toBeInTheDocument();
+			});
+		});
+
+		it('handles malformed error JSON gracefully', async () => {
+			const { queryByText, getByText } = render(<Login />, undefined, {
+				initialRoute:
+					'/login?callbackauthnerr=true&code=AUTH_ERROR&message=Authentication failed&errors=invalid-json',
+			});
+
+			await waitFor(() => {
+				expect(queryByText('invalid-json')).not.toBeInTheDocument();
+				expect(getByText('AUTH_ERROR')).toBeInTheDocument();
+			});
+		});
+	});
+
+	describe('Session Organization Warnings', () => {
+		it('shows warning modal when org has warning', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (req, res, ctx) =>
+					res(
+						ctx.status(200),
+						ctx.json({ status: 'success', data: mockOrgWithWarning }),
+					),
+				),
+			);
+
+			render(<Login />);
+
+			const emailInput = screen.getByTestId('email');
+			const nextButton = screen.getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			await waitFor(() => {
+				expect(
+					screen.getByText(/organization has limited access/i),
+				).toBeInTheDocument();
+			});
+		});
+
+		it('shows warning modal when a warning org is selected among multiple orgs', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			// Mock multiple orgs including one with a warning
+			const mockMultiOrgWithWarning = {
+				orgs: [
+					{ id: 'org1', name: 'Org 1' },
+					{
+						id: 'org2',
+						name: 'Org 2',
+						warning: {
+							code: 'ORG_WARNING',
+							message: 'Organization has limited access',
+							url: 'https://example.com/warning',
+							errors: [{ message: 'Contact admin for full access' }],
+						} as ErrorV2,
+					},
+				],
+			};
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (_, res, ctx) =>
+					res(
+						ctx.status(200),
+						ctx.json({ status: 'success', data: mockMultiOrgWithWarning }),
+					),
+				),
+			);
+
+			const { getByTestId } = render(<Login />);
+
+			const emailInput = getByTestId('email');
+			const nextButton = getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			await waitFor(() => {
+				expect(screen.getByRole('combobox')).toBeInTheDocument();
+			});
+
+			// Select the organization with a warning
+			await user.click(screen.getByRole('combobox'));
+			await user.click(screen.getByText('Org 2'));
+
+			await waitFor(() => {
+				expect(
+					screen.getByText(/organization has limited access/i),
+				).toBeInTheDocument();
+			});
+		});
+	});
+
+	describe('Form State Management', () => {
+		it('disables form fields during loading states', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (req, res, ctx) =>
+					res(
+						ctx.delay(100),
+						ctx.status(200),
+						ctx.json({ data: mockSingleOrgPasswordAuth }),
+					),
+				),
+			);
+
+			render(<Login />);
+
+			const emailInput = screen.getByTestId('email');
+			const nextButton = screen.getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			// Button should be disabled during API call
+			expect(nextButton).toBeDisabled();
+		});
+
+		it('shows correct button text for each auth method', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (req, res, ctx) =>
+					res(ctx.status(200), ctx.json({ data: mockSingleOrgPasswordAuth })),
+				),
+			);
+
+			render(<Login />);
+
+			// Initially shows "Next" button
+			expect(screen.getByTestId('initiate_login')).toBeInTheDocument();
+
+			const emailInput = screen.getByTestId('email');
+			const nextButton = screen.getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			await waitFor(() => {
+				// Should show "Login" button for password auth
+				expect(screen.getByTestId('password_authn_submit')).toBeInTheDocument();
+				expect(screen.queryByTestId('initiate_login')).not.toBeInTheDocument();
+			});
+		});
+	});
+
+	describe('Edge Cases', () => {
+		it('handles user with no organizations', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			const mockNoOrgs: SessionsContext = {
+				exists: false,
+				orgs: [],
+			};
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (req, res, ctx) =>
+					res(ctx.status(200), ctx.json({ data: mockNoOrgs })),
+				),
+			);
+
+			render(<Login />);
+
+			const emailInput = screen.getByTestId('email');
+			const nextButton = screen.getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			await waitFor(() => {
+				// Should not show any auth method buttons
+				expect(
+					screen.queryByTestId('password_authn_submit'),
+				).not.toBeInTheDocument();
+				expect(
+					screen.queryByTestId('callback_authn_submit'),
+				).not.toBeInTheDocument();
+			});
+		});
+
+		it('handles organization with no auth support', async () => {
+			const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+			const mockNoAuthSupport: SessionsContext = {
+				exists: true,
+				orgs: [
+					{
+						id: 'org-1',
+						name: 'No Auth Organization',
+						authNSupport: {
+							password: [],
+							callback: [],
+						},
+					},
+				],
+			};
+
+			server.use(
+				rest.get(SESSIONS_CONTEXT_ENDPOINT, (req, res, ctx) =>
+					res(ctx.status(200), ctx.json({ data: mockNoAuthSupport })),
+				),
+			);
+
+			render(<Login />);
+
+			const emailInput = screen.getByTestId('email');
+			const nextButton = screen.getByTestId('initiate_login');
+
+			await user.type(emailInput, PASSWORD_AUTHN_EMAIL);
+			await user.click(nextButton);
+
+			await waitFor(() => {
+				// Should not show any auth method buttons
+				expect(
+					screen.queryByTestId('password_authn_submit'),
+				).not.toBeInTheDocument();
+				expect(
+					screen.queryByTestId('callback_authn_submit'),
+				).not.toBeInTheDocument();
+			});
 		});
 	});
 });

frontend/src/container/Login/index.tsx

@@ -1,213 +1,255 @@
 import './Login.styles.scss';
 
-import { Button, Form, Input, Space, Tooltip, Typography } from 'antd';
-import getLocalStorageApi from 'api/browser/localstorage/get';
-import setLocalStorageApi from 'api/browser/localstorage/set';
-import loginApi from 'api/v1/login/login';
-import loginPrecheckApi from 'api/v1/login/loginPrecheck';
-import getUserVersion from 'api/v1/version/getVersion';
+import { Button, Form, Input, Select, Space, Tooltip, Typography } from 'antd';
+import getVersion from 'api/v1/version/get';
+import get from 'api/v2/sessions/context/get';
+import post from 'api/v2/sessions/email_password/post';
 import afterLogin from 'AppRoutes/utils';
-import { LOCALSTORAGE } from 'constants/localStorage';
 import ROUTES from 'constants/routes';
-import { useNotifications } from 'hooks/useNotifications';
+import useUrlQuery from 'hooks/useUrlQuery';
 import history from 'lib/history';
 import { ArrowRight } from 'lucide-react';
-import { useAppContext } from 'providers/App/App';
-import { useEffect, useState } from 'react';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import { useEffect, useMemo, useState } from 'react';
 import { useQuery } from 'react-query';
+import { ErrorV2 } from 'types/api';
 import APIError from 'types/api/error';
-import { Signup as PrecheckResultType } from 'types/api/user/loginPrecheck';
+import { SessionsContext } from 'types/api/v2/sessions/context/get';
 
 import { FormContainer, Label, ParentContainer } from './styles';
 
-interface LoginProps {
-	jwt: string;
-	refreshjwt: string;
-	userId: string;
-	ssoerror: string;
-	withPassword: string;
+function parseErrors(errors: string): { message: string }[] {
+	try {
+		const parsedErrors = JSON.parse(errors);
+		return parsedErrors.map((error: { message: string }) => ({
+			message: error.message,
+		}));
+	} catch (e) {
+		console.error('Failed to parse errors:', e);
+		return [];
+	}
 }
 
-type FormValues = { email: string; password: string };
+type FormValues = {
+	email: string;
+	password: string;
+	orgId: string;
+	url: string;
+};
 
-function Login({
-	jwt,
-	refreshjwt,
-	userId,
-	ssoerror = '',
-	withPassword = '0',
-}: LoginProps): JSX.Element {
-	const [isLoading, setIsLoading] = useState<boolean>(false);
-	const { user } = useAppContext();
+function Login(): JSX.Element {
+	const urlQueryParams = useUrlQuery();
+	// override for callbackAuthN in case of some misconfiguration
+	const isPasswordAuthNEnabled = (urlQueryParams.get('password') || 'N') === 'Y';
 
-	const [precheckResult, setPrecheckResult] = useState<PrecheckResultType>({
-		sso: false,
-		ssoUrl: '',
-		canSelfRegister: false,
-		isUser: true,
-	});
+	// callbackAuthN handling
+	const accessToken = urlQueryParams.get('accessToken') || '';
+	const refreshToken = urlQueryParams.get('refreshToken') || '';
 
-	const [precheckInProcess, setPrecheckInProcess] = useState(false);
-	const [precheckComplete, setPrecheckComplete] = useState(false);
+	// callbackAuthN error handling
+	const callbackAuthError = urlQueryParams.get('callbackauthnerr') || '';
+	const callbackAuthErrorCode = urlQueryParams.get('code') || '';
+	const callbackAuthErrorMessage = urlQueryParams.get('message') || '';
+	const callbackAuthErrorURL = urlQueryParams.get('url') || '';
+	const callbackAuthErrorAdditional = urlQueryParams.get('errors') || '';
 
-	const { notifications } = useNotifications();
+	const [sessionsContext, setSessionsContext] = useState<SessionsContext>();
+	const [isSubmitting, setIsSubmitting] = useState<boolean>(false);
+	const [sessionsOrgId, setSessionsOrgId] = useState<string>('');
+	const [
+		sessionsContextLoading,
+		setIsLoadingSessionsContext,
+	] = useState<boolean>(false);
+	const [form] = Form.useForm<FormValues>();
+	const { showErrorModal } = useErrorModal();
 
-	const getUserVersionResponse = useQuery({
-		queryFn: getUserVersion,
-		queryKey: ['getUserVersion', user?.accessJwt],
+	// setupCompleted information to route to signup page in case setup is incomplete
+	const {
+		data: versionData,
+		isLoading: versionLoading,
+		error: versionError,
+	} = useQuery({
+		queryFn: getVersion,
+		queryKey: ['api/v1/version/get'],
 		enabled: true,
 	});
 
+	// in case of error do not route to signup page as it may lead to double registration
 	useEffect(() => {
 		if (
-			getUserVersionResponse.isFetched &&
-			getUserVersionResponse.data &&
-			getUserVersionResponse.data.payload
+			versionData &&
+			!versionLoading &&
+			!versionError &&
+			!versionData.data.setupCompleted
 		) {
-			const { setupCompleted } = getUserVersionResponse.data.payload;
-			if (!setupCompleted) {
-				// no org account registered yet, re-route user to sign up first
-				history.push(ROUTES.SIGN_UP);
-			}
+			history.push(ROUTES.SIGN_UP);
 		}
-	}, [getUserVersionResponse]);
-
-	const [form] = Form.useForm<FormValues>();
-
-	useEffect(() => {
-		if (withPassword === 'Y') {
-			setPrecheckComplete(true);
-		}
-	}, [withPassword]);
-
-	useEffect(() => {
-		async function processJwt(): Promise<void> {
-			if (jwt && jwt !== '') {
-				setIsLoading(true);
-				await afterLogin(userId, jwt, refreshjwt);
-				setIsLoading(false);
-				const fromPathname = getLocalStorageApi(
-					LOCALSTORAGE.UNAUTHENTICATED_ROUTE_HIT,
-				);
-				if (fromPathname) {
-					history.push(fromPathname);
-					setLocalStorageApi(LOCALSTORAGE.UNAUTHENTICATED_ROUTE_HIT, '');
-				} else {
-					history.push(ROUTES.APPLICATION);
-				}
-			}
-		}
-		processJwt();
-	}, [jwt, refreshjwt, userId]);
-
-	useEffect(() => {
-		if (ssoerror !== '') {
-			notifications.error({
-				message: 'sorry, failed to login',
-			});
-		}
-	}, [ssoerror, notifications]);
+	}, [versionData, versionLoading, versionError]);
 
+	// fetch the sessions context post user entering the email
 	const onNextHandler = async (): Promise<void> => {
 		const email = form.getFieldValue('email');
-		if (!email) {
-			notifications.error({
-				message: 'Please enter a valid email address',
-			});
-			return;
-		}
-		setPrecheckInProcess(true);
+		setIsLoadingSessionsContext(true);
+
 		try {
-			const response = await loginPrecheckApi({
+			const sessionsContextResponse = await get({
 				email,
+				ref: window.location.href,
 			});
 
-			if (response.statusCode === 200) {
-				setPrecheckResult({ ...precheckResult, ...response.payload });
-
-				const { isUser } = response.payload;
-				if (isUser) {
-					setPrecheckComplete(true);
-				} else {
-					notifications.error({
-						message:
-							'This account does not exist. To create a new account, contact your admin to get an invite link',
-					});
-				}
-			} else {
-				notifications.error({
-					message:
-						'Invalid configuration detected, please contact your administrator',
-				});
+			setSessionsContext(sessionsContextResponse.data);
+			if (sessionsContextResponse.data.orgs.length === 1) {
+				setSessionsOrgId(sessionsContextResponse.data.orgs[0].id);
 			}
-		} catch (e) {
-			console.log('failed to call precheck Api', e);
-			notifications.error({ message: 'Sorry, something went wrong' });
-		}
-		setPrecheckInProcess(false);
-	};
-
-	const { sso, canSelfRegister } = precheckResult;
-
-	const onSubmitHandler: () => Promise<void> = async () => {
-		try {
-			const { email, password } = form.getFieldsValue();
-			if (!precheckComplete) {
-				onNextHandler();
-				return;
-			}
-
-			if (precheckComplete && sso) {
-				window.location.href = precheckResult.ssoUrl || '';
-				return;
-			}
-
-			setIsLoading(true);
-
-			const response = await loginApi({
-				email,
-				password,
-			});
-
-			afterLogin(
-				response.data.userId,
-				response.data.accessJwt,
-				response.data.refreshJwt,
-			);
-			setIsLoading(false);
 		} catch (error) {
-			setIsLoading(false);
-			notifications.error({
-				message: (error as APIError).getErrorCode(),
-				description: (error as APIError).getErrorMessage(),
-			});
+			showErrorModal(error as APIError);
 		}
+		setIsLoadingSessionsContext(false);
 	};
 
-	const renderSAMLAction = (): JSX.Element => (
-		<Button
-			type="primary"
-			loading={isLoading}
-			disabled={isLoading}
-			href={precheckResult.ssoUrl}
-		>
-			Login with SSO
-		</Button>
-	);
+	// post selection of email and session org decide on the authN mechanism to use
+	const isPasswordAuthN = useMemo((): boolean => {
+		if (!sessionsContext) {
+			return false;
+		}
 
-	const renderOnSsoError = (): JSX.Element | null => {
-		if (!ssoerror) {
+		if (!sessionsOrgId) {
+			return false;
+		}
+
+		let isPasswordAuthN = false;
+		sessionsContext.orgs.forEach((orgSession) => {
+			if (
+				orgSession.id === sessionsOrgId &&
+				orgSession.authNSupport?.password?.length > 0
+			) {
+				isPasswordAuthN = true;
+			}
+		});
+
+		return isPasswordAuthN || isPasswordAuthNEnabled;
+	}, [sessionsContext, sessionsOrgId, isPasswordAuthNEnabled]);
+
+	const isCallbackAuthN = useMemo((): boolean => {
+		if (!sessionsContext) {
+			return false;
+		}
+
+		if (!sessionsOrgId) {
+			return false;
+		}
+
+		let isCallbackAuthN = false;
+		sessionsContext.orgs.forEach((orgSession) => {
+			if (
+				orgSession.id === sessionsOrgId &&
+				orgSession.authNSupport?.callback?.length > 0
+			) {
+				isCallbackAuthN = true;
+				form.setFieldValue('url', orgSession.authNSupport.callback[0].url);
+			}
+		});
+
+		return isCallbackAuthN && !isPasswordAuthNEnabled;
+	}, [sessionsContext, sessionsOrgId, isPasswordAuthNEnabled, form]);
+
+	const sessionsOrgWarning = useMemo((): ErrorV2 | null => {
+		if (!sessionsContext) {
 			return null;
 		}
 
-		return (
-			<Typography.Paragraph italic style={{ color: '#ACACAC' }}>
-				Are you trying to resolve SSO configuration issue?{' '}
-				<a href="/login?password=Y">Login with password</a>.
-			</Typography.Paragraph>
-		);
+		if (!sessionsOrgId) {
+			return null;
+		}
+
+		let sessionsOrgWarning;
+		sessionsContext.orgs.forEach((orgSession) => {
+			if (orgSession.id === sessionsOrgId && orgSession.warning) {
+				sessionsOrgWarning = orgSession.warning;
+			}
+		});
+
+		return sessionsOrgWarning || null;
+	}, [sessionsContext, sessionsOrgId]);
+
+	// once the callback authN redirects to the login screen with access_token and refresh_token navigate them to homepage
+	useEffect(() => {
+		if (accessToken && refreshToken) {
+			afterLogin(accessToken, refreshToken);
+		}
+	}, [accessToken, refreshToken]);
+
+	const onSubmitHandler: () => Promise<void> = async () => {
+		setIsSubmitting(true);
+
+		try {
+			if (isPasswordAuthN) {
+				const email = form.getFieldValue('email');
+
+				const password = form.getFieldValue('password');
+
+				const createSessionEmailPasswordResponse = await post({
+					email,
+					password,
+					orgId: sessionsOrgId,
+				});
+
+				afterLogin(
+					createSessionEmailPasswordResponse.data.accessToken,
+					createSessionEmailPasswordResponse.data.refreshToken,
+				);
+			}
+			if (isCallbackAuthN) {
+				const url = form.getFieldValue('url');
+
+				window.location.href = url;
+			}
+		} catch (error) {
+			showErrorModal(error as APIError);
+		} finally {
+			setIsSubmitting(false);
+		}
 	};
 
+	useEffect(() => {
+		if (callbackAuthError) {
+			showErrorModal(
+				new APIError({
+					httpStatusCode: 500,
+					error: {
+						code: callbackAuthErrorCode,
+						message: callbackAuthErrorMessage,
+						url: callbackAuthErrorURL,
+						errors: parseErrors(callbackAuthErrorAdditional),
+					},
+				}),
+			);
+		}
+	}, [
+		callbackAuthError,
+		callbackAuthErrorAdditional,
+		callbackAuthErrorCode,
+		callbackAuthErrorMessage,
+		callbackAuthErrorURL,
+		showErrorModal,
+	]);
+
+	useEffect(() => {
+		if (sessionsOrgWarning) {
+			showErrorModal(
+				new APIError({
+					error: {
+						code: sessionsOrgWarning.code,
+						message: sessionsOrgWarning.message,
+						url: sessionsOrgWarning.url,
+						errors: sessionsOrgWarning.errors,
+					},
+					httpStatusCode: 400,
+				}),
+			);
+		}
+	}, [sessionsOrgWarning, showErrorModal]);
+
 	return (
 		<div className="login-form-container">
 			<FormContainer form={form} onFinish={onSubmitHandler}>
@@ -225,17 +267,39 @@ function Login({
 					<FormContainer.Item name="email">
 						<Input
 							type="email"
-							id="loginEmail"
+							id="email"
 							data-testid="email"
 							required
 							placeholder="name@yourcompany.com"
 							autoFocus
-							disabled={isLoading}
+							disabled={versionLoading}
 							className="login-form-input"
 						/>
 					</FormContainer.Item>
 				</ParentContainer>
-				{precheckComplete && !sso && (
+
+				{sessionsContext && sessionsContext.orgs.length > 1 && (
+					<ParentContainer>
+						<Label htmlFor="orgId">Organization Name</Label>
+						<FormContainer.Item name="orgId">
+							<Select
+								id="orgId"
+								data-testid="orgId"
+								className="login-form-input"
+								placeholder="Select your organization"
+								options={sessionsContext.orgs.map((org) => ({
+									value: org.id,
+									label: org.name || 'default',
+								}))}
+								onChange={(value: string): void => {
+									setSessionsOrgId(value);
+								}}
+							/>
+						</FormContainer.Item>
+					</ParentContainer>
+				)}
+
+				{sessionsContext && isPasswordAuthN && (
 					<ParentContainer>
 						<Label htmlFor="Password">Password</Label>
 						<FormContainer.Item name="password">
@@ -243,7 +307,7 @@ function Login({
 								required
 								id="currentPassword"
 								data-testid="password"
-								disabled={isLoading}
+								disabled={isSubmitting}
 								className="login-form-input"
 							/>
 						</FormContainer.Item>
@@ -255,16 +319,16 @@ function Login({
 						</div>
 					</ParentContainer>
 				)}
+
 				<Space
 					style={{ marginTop: 16 }}
 					align="start"
 					direction="vertical"
 					size={20}
 				>
-					{!precheckComplete && (
+					{!sessionsContext && (
 						<Button
-							disabled={precheckInProcess}
-							loading={precheckInProcess}
+							disabled={versionLoading || sessionsContextLoading}
 							type="primary"
 							onClick={onNextHandler}
 							data-testid="initiate_login"
@@ -274,12 +338,27 @@ function Login({
 							Next
 						</Button>
 					)}
-					{precheckComplete && !sso && (
+
+					{sessionsContext && isCallbackAuthN && (
 						<Button
-							disabled={isLoading}
-							loading={isLoading}
+							disabled={isSubmitting}
 							type="primary"
 							htmlType="submit"
+							data-testid="callback_authn_submit"
+							data-attr="signup"
+							className="periscope-btn primary next-btn"
+							icon={<ArrowRight size={12} />}
+						>
+							Login With Callback
+						</Button>
+					)}
+
+					{sessionsContext && isPasswordAuthN && (
+						<Button
+							disabled={isSubmitting}
+							type="primary"
+							data-testid="password_authn_submit"
+							htmlType="submit"
 							data-attr="signup"
 							className="periscope-btn primary next-btn"
 							icon={<ArrowRight size={12} />}
@@ -287,30 +366,6 @@ function Login({
 							Login
 						</Button>
 					)}
-
-					{precheckComplete && sso && renderSAMLAction()}
-					{!precheckComplete && ssoerror && renderOnSsoError()}
-
-					{!canSelfRegister && (
-						<Typography.Paragraph className="no-acccount">
-							Don&apos;t have an account? Contact your admin to send you an invite
-							link.
-						</Typography.Paragraph>
-					)}
-
-					{canSelfRegister && (
-						<Typography.Paragraph italic style={{ color: '#ACACAC' }}>
-							If you are admin,{' '}
-							<Typography.Link
-								onClick={(): void => {
-									history.push(ROUTES.SIGN_UP);
-								}}
-								style={{ fontWeight: 700 }}
-							>
-								Create an account
-							</Typography.Link>
-						</Typography.Paragraph>
-					)}
 				</Space>
 			</FormContainer>
 		</div>

frontend/src/container/LogsExplorerViews/LogsActionsContainer.tsx

@@ -1,6 +1,4 @@
 import { Switch, Typography } from 'antd';
-import { WsDataEvent } from 'api/common/getQueryStats';
-import { getYAxisFormattedValue } from 'components/Graph/yAxisConfig';
 import LogsDownloadOptionsMenu from 'components/LogsDownloadOptionsMenu/LogsDownloadOptionsMenu';
 import LogsFormatOptionsMenu from 'components/LogsFormatOptionsMenu/LogsFormatOptionsMenu';
 import ListViewOrderBy from 'components/OrderBy/ListViewOrderBy';
@@ -14,7 +12,6 @@ import QueryStatus from './QueryStatus';
 
 function LogsActionsContainer({
 	listQuery,
-	queryStats,
 	selectedPanelType,
 	showFrequencyChart,
 	handleToggleFrequencyChart,
@@ -37,7 +34,6 @@ function LogsActionsContainer({
 	isLoading: boolean;
 	isError: boolean;
 	isSuccess: boolean;
-	queryStats: WsDataEvent | undefined;
 	minTime: number;
 	maxTime: number;
 }): JSX.Element {
@@ -126,22 +122,6 @@ function LogsActionsContainer({
 								error={isError}
 								success={isSuccess}
 							/>
-
-							{queryStats?.read_rows && (
-								<Typography.Text className="rows">
-									{getYAxisFormattedValue(queryStats.read_rows?.toString(), 'short')}{' '}
-									rows
-								</Typography.Text>
-							)}
-
-							{queryStats?.elapsed_ms && (
-								<>
-									<div className="divider" />
-									<Typography.Text className="time">
-										{getYAxisFormattedValue(queryStats?.elapsed_ms?.toString(), 'ms')}
-									</Typography.Text>
-								</>
-							)}
 						</div>
 					)}
 				</div>

frontend/src/container/LogsExplorerViews/index.tsx

@@ -3,7 +3,6 @@ import './LogsExplorerViews.styles.scss';
 
 import getFromLocalstorage from 'api/browser/localstorage/get';
 import setToLocalstorage from 'api/browser/localstorage/set';
-import { getQueryStats, WsDataEvent } from 'api/common/getQueryStats';
 import logEvent from 'api/common/logEvent';
 import { ENTITY_VERSION_V5 } from 'constants/app';
 import { LOCALSTORAGE } from 'constants/localStorage';
@@ -132,7 +131,6 @@ function LogsExplorerViewsContainer({
 	const [logs, setLogs] = useState<ILog[]>([]);
 	const [requestData, setRequestData] = useState<Query | null>(null);
 	const [queryId, setQueryId] = useState<string>(v4());
-	const [queryStats, setQueryStats] = useState<WsDataEvent>();
 	const [listChartQuery, setListChartQuery] = useState<Query | null>(null);
 
 	const [orderBy, setOrderBy] = useState<string>('timestamp:desc');
@@ -409,19 +407,6 @@ function LogsExplorerViewsContainer({
 		setQueryId(v4());
 	}, [data]);
 
-	useEffect(() => {
-		if (
-			!isEmpty(queryId) &&
-			(isLoading || isFetching) &&
-			selectedPanelType !== PANEL_TYPES.LIST
-		) {
-			setQueryStats(undefined);
-			setTimeout(() => {
-				getQueryStats({ queryId, setData: setQueryStats });
-			}, 500);
-		}
-	}, [queryId, isLoading, isFetching, selectedPanelType]);
-
 	const logEventCalledRef = useRef(false);
 	useEffect(() => {
 		if (!logEventCalledRef.current && !isUndefined(data?.payload)) {
@@ -632,7 +617,6 @@ function LogsExplorerViewsContainer({
 				{!showLiveLogs && (
 					<LogsActionsContainer
 						listQuery={listQuery}
-						queryStats={queryStats}
 						selectedPanelType={selectedPanelType}
 						showFrequencyChart={showFrequencyChart}
 						handleToggleFrequencyChart={handleToggleFrequencyChart}

frontend/src/container/LogsExplorerViews/tests/LogsExplorerViews.test.tsx

@@ -52,10 +52,6 @@ jest.mock(
 		},
 );
 
-jest.mock('api/common/getQueryStats', () => ({
-	getQueryStats: jest.fn(),
-}));
-
 jest.mock('constants/panelTypes', () => ({
 	AVAILABLE_EXPORT_PANEL_TYPES: ['graph', 'table'],
 }));

frontend/src/container/MeterExplorer/Breakdown/BreakDown.tsx

@@ -1,19 +1,25 @@
 import './BreakDown.styles.scss';
 
 import { Alert, Typography } from 'antd';
+import getLocalStorageApi from 'api/browser/localstorage/get';
+import setLocalStorageApi from 'api/browser/localstorage/set';
+import { LOCALSTORAGE } from 'constants/localStorage';
 import { QueryParams } from 'constants/query';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import GridCard from 'container/GridCardLayout/GridCard';
 import { Card, CardContainer } from 'container/GridCardLayout/styles';
 import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
+import dayjs from 'dayjs';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { useCallback } from 'react';
-import { useDispatch } from 'react-redux';
+import { useDispatch, useSelector } from 'react-redux';
 import { useHistory, useLocation } from 'react-router-dom';
 import { UpdateTimeInterval } from 'store/actions';
+import { AppState } from 'store/reducers';
 import { Widgets } from 'types/api/dashboard/getAll';
+import { GlobalReducer } from 'types/reducer/globalTime';
 import { v4 as uuid } from 'uuid';
 
 import {
@@ -108,27 +114,66 @@ function Section(section: MetricSection): JSX.Element {
 
 function BreakDown(): JSX.Element {
 	const { isCloudUser } = useGetTenantLicense();
+	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
+		(state) => state.globalTime,
+	);
+
+	const showInfo =
+		getLocalStorageApi(LOCALSTORAGE.DISSMISSED_COST_METER_INFO) !== 'true';
+	const isDateBeforeAugust22nd2025 = (minTime: number): boolean => {
+		const august22nd2025UTC = dayjs.utc('2025-08-22T00:00:00Z');
+		return dayjs(minTime / 1e6).isBefore(august22nd2025UTC);
+	};
+	const showShortRangeWarning = (maxTime - minTime) / 1e6 < 61 * 60 * 1000;
+
 	return (
 		<div className="meter-explorer-breakdown">
 			<section className="meter-explorer-date-time">
 				<DateTimeSelectionV2 showAutoRefresh={false} />
 			</section>
 			<section className="meter-explorer-graphs">
-				<section className="info">
+				{showInfo && (
 					<Alert
 						type="info"
 						showIcon
+						closable
+						onClose={(): void => {
+							setLocalStorageApi(LOCALSTORAGE.DISSMISSED_COST_METER_INFO, 'true');
+						}}
 						message="Billing is calculated in UTC. To match your meter data with billing, select full-day ranges in UTC time (00:00 – 23:59 UTC). 
-						For example, if you’re in IST, for the billing of Jan 1, select your time range as Jan 1, 5:30 AM – Jan 2, 5:29 AM IST."
+						For example, if you’re in PT, for the billing of Jan 1, select your time range as Dec 31, 4:00 PM – Jan 1, 3:59 PM PT."
 					/>
-					{isCloudUser && (
-						<Alert
-							type="warning"
-							showIcon
-							message="Meter module data is accurate only from 22nd August 2025, 00:00 UTC onwards. Data before this time was collected during the beta phase and may be inaccurate."
-						/>
-					)}
-				</section>
+				)}
+				{isCloudUser && isDateBeforeAugust22nd2025(minTime) && (
+					<Alert
+						type="warning"
+						showIcon
+						message="Meter module data is accurate only from 22nd August 2025, 00:00 UTC onwards. Data before this time was collected during the beta phase and may be inaccurate."
+					/>
+				)}
+
+				{showShortRangeWarning && (
+					<Alert
+						type="warning"
+						showIcon
+						closable
+						message={
+							<>
+								Meter metrics data is aggregated over 1 hour period. Please select time
+								range accordingly.&nbsp;
+								<a
+									href="https://signoz.io/docs/cost-meter/overview/#accessing-cost-meter"
+									rel="noopener noreferrer"
+									target="_blank"
+									style={{ textDecoration: 'underline' }}
+								>
+									Learn more
+								</a>
+								.
+							</>
+						}
+					/>
+				)}
 				<section className="total">
 					<Section
 						id={sections[0].id}

frontend/src/container/MySettings/Password/index.tsx

@@ -1,154 +0,0 @@
-import { Button, Card, Space, Typography } from 'antd';
-import changeMyPassword from 'api/v1/factor_password/changeMyPassword';
-import { useNotifications } from 'hooks/useNotifications';
-import { Save } from 'lucide-react';
-import { isPasswordNotValidMessage, isPasswordValid } from 'pages/SignUp/utils';
-import { useAppContext } from 'providers/App/App';
-import { useEffect, useState } from 'react';
-import { useTranslation } from 'react-i18next';
-import APIError from 'types/api/error';
-
-import { Password } from '../styles';
-
-function PasswordContainer(): JSX.Element {
-	const [currentPassword, setCurrentPassword] = useState<string>('');
-	const [updatePassword, setUpdatePassword] = useState<string>('');
-	const { t } = useTranslation(['routes', 'settings', 'common']);
-	const { user } = useAppContext();
-	const [isLoading, setIsLoading] = useState<boolean>(false);
-	const [isPasswordPolicyError, setIsPasswordPolicyError] = useState<boolean>(
-		false,
-	);
-
-	const defaultPlaceHolder = '*************';
-
-	const { notifications } = useNotifications();
-
-	useEffect(() => {
-		if (currentPassword && !isPasswordValid(currentPassword)) {
-			setIsPasswordPolicyError(true);
-		} else {
-			setIsPasswordPolicyError(false);
-		}
-	}, [currentPassword]);
-
-	if (!user) {
-		return <div />;
-	}
-
-	const onChangePasswordClickHandler = async (): Promise<void> => {
-		try {
-			setIsLoading(true);
-
-			if (!isPasswordValid(currentPassword)) {
-				setIsPasswordPolicyError(true);
-				setIsLoading(false);
-				return;
-			}
-			await changeMyPassword({
-				newPassword: updatePassword,
-				oldPassword: currentPassword,
-				userId: user.id,
-			});
-			notifications.success({
-				message: t('success', {
-					ns: 'common',
-				}),
-			});
-			setIsLoading(false);
-		} catch (error) {
-			setIsLoading(false);
-			notifications.error({
-				message: (error as APIError).error.error.code,
-				description: (error as APIError).error.error.message,
-			});
-		}
-	};
-
-	const isDisabled =
-		isLoading ||
-		currentPassword.length === 0 ||
-		updatePassword.length === 0 ||
-		isPasswordPolicyError ||
-		currentPassword === updatePassword;
-
-	return (
-		<Card className="reset-password-card">
-			<Space direction="vertical" size="small">
-				<Typography.Title
-					level={4}
-					style={{ marginTop: 0 }}
-					data-testid="change-password-header"
-				>
-					{t('change_password', {
-						ns: 'settings',
-					})}
-				</Typography.Title>
-				<Space direction="vertical">
-					<Typography data-testid="current-password-label">
-						{t('current_password', {
-							ns: 'settings',
-						})}
-					</Typography>
-					<Password
-						data-testid="current-password-textbox"
-						disabled={isLoading}
-						placeholder={defaultPlaceHolder}
-						onChange={(event): void => {
-							setCurrentPassword(event.target.value);
-						}}
-						value={currentPassword}
-					/>
-				</Space>
-				<Space direction="vertical">
-					<Typography data-testid="new-password-label">
-						{t('new_password', {
-							ns: 'settings',
-						})}
-					</Typography>
-					<Password
-						data-testid="new-password-textbox"
-						disabled={isLoading}
-						placeholder={defaultPlaceHolder}
-						onChange={(event): void => {
-							const updatedValue = event.target.value;
-							setUpdatePassword(updatedValue);
-						}}
-						value={updatePassword}
-					/>
-				</Space>
-				<Space>
-					{isPasswordPolicyError && (
-						<Typography.Paragraph
-							data-testid="validation-message"
-							style={{
-								color: '#D89614',
-								marginTop: '0.50rem',
-							}}
-						>
-							{isPasswordNotValidMessage}
-						</Typography.Paragraph>
-					)}
-				</Space>
-				<Button
-					disabled={isDisabled}
-					loading={isLoading}
-					onClick={onChangePasswordClickHandler}
-					type="primary"
-					data-testid="update-password-button"
-				>
-					<Save
-						size={12}
-						style={{ marginRight: '8px' }}
-						data-testid="update-password-icon"
-					/>{' '}
-					{t('change_password', {
-						ns: 'settings',
-					})}
-				</Button>
-			</Space>
-		</Card>
-	);
-}
-
-export default PasswordContainer;

frontend/src/container/MySettings/UserInfo/index.tsx

@@ -7,9 +7,8 @@ import changeMyPassword from 'api/v1/factor_password/changeMyPassword';
 import editUser from 'api/v1/user/id/update';
 import { useNotifications } from 'hooks/useNotifications';
 import { Check, FileTerminal, MailIcon, UserIcon } from 'lucide-react';
-import { isPasswordValid } from 'pages/SignUp/utils';
 import { useAppContext } from 'providers/App/App';
-import { useEffect, useState } from 'react';
+import { useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import APIError from 'types/api/error';
 
@@ -22,9 +21,6 @@ function UserInfo(): JSX.Element {
 	const [currentPassword, setCurrentPassword] = useState<string>('');
 	const [updatePassword, setUpdatePassword] = useState<string>('');
 	const [isLoading, setIsLoading] = useState<boolean>(false);
-	const [isPasswordPolicyError, setIsPasswordPolicyError] = useState<boolean>(
-		false,
-	);
 
 	const [changedName, setChangedName] = useState<string>(
 		user?.displayName || '',
@@ -40,14 +36,6 @@ function UserInfo(): JSX.Element {
 
 	const defaultPlaceHolder = '*************';
 
-	useEffect(() => {
-		if (currentPassword && !isPasswordValid(currentPassword)) {
-			setIsPasswordPolicyError(true);
-		} else {
-			setIsPasswordPolicyError(false);
-		}
-	}, [currentPassword]);
-
 	if (!user) {
 		return <div />;
 	}
@@ -64,11 +52,6 @@ function UserInfo(): JSX.Element {
 		try {
 			setIsLoading(true);
 
-			if (!isPasswordValid(currentPassword)) {
-				setIsPasswordPolicyError(true);
-				setIsLoading(false);
-				return;
-			}
 			await changeMyPassword({
 				newPassword: updatePassword,
 				oldPassword: currentPassword,
@@ -94,7 +77,6 @@ function UserInfo(): JSX.Element {
 		isLoading ||
 		currentPassword.length === 0 ||
 		updatePassword.length === 0 ||
-		isPasswordPolicyError ||
 		currentPassword === updatePassword;
 
 	const onSaveHandler = async (): Promise<void> => {

frontend/src/container/OnboardingContainer/OnboardingContainer.tsx

@@ -408,6 +408,7 @@ export default function Onboarding(): JSX.Element {
 				form={form}
 				isInviteTeamMemberModalOpen={isInviteTeamMemberModalOpen}
 				toggleModal={toggleModal}
+				onClose={(): void => {}}
 			/>
 		</div>
 	);

frontend/src/container/OnboardingV2Container/onboarding-configs/onboarding-config-with-links.json

@@ -87,13 +87,31 @@
 		"imgUrl": "/Logos/signoz-brand-logo.svg",
 		"link": "https://signoz.io/docs/migration/migrate-from-signoz-self-host-to-signoz-cloud/"
 	},
+	{
+		"dataSource": "migrate-from-existing-opentelemetry",
+		"label": "From Existing OpenTelemetry",
+		"tags": ["migrate to SigNoz"],
+		"module": "home",
+		"relatedSearchKeywords": [
+			"apm migration",
+			"opentelemetry",
+			"migration guide",
+			"migrate",
+			"migration",
+			"otel collector",
+			"opentelemetry collector",
+			"otlp"
+		],
+		"imgUrl": "/Logos/opentelemetry.svg",
+		"link": "https://signoz.io/docs/migration/migrate-from-opentelemetry-to-signoz/"
+	},
 	{
 		"dataSource": "java",
 		"entityID": "dataSource",
 		"label": "Java",
 		"id": "java",
 		"imgUrl": "/Logos/java.svg",
-		"tags": ["apm"],
+		"tags": ["apm/traces"],
 		"module": "apm",
 		"relatedSearchKeywords": [
 			"apm",
@@ -285,7 +303,7 @@
 		"dataSource": "python",
 		"label": "Python",
 		"imgUrl": "/Logos/python.svg",
-		"tags": ["apm"],
+		"tags": ["apm/traces"],
 		"module": "apm",
 		"relatedSearchKeywords": [
 			"apm",
@@ -450,7 +468,7 @@
 	{
 		"dataSource": "javascript",
 		"label": "JavaScript",
-		"tags": ["apm"],
+		"tags": ["apm/traces"],
 		"module": "apm",
 		"relatedSearchKeywords": [
 			"apm",
@@ -697,7 +715,7 @@
 		"dataSource": "golang",
 		"label": "Golang",
 		"imgUrl": "/Logos/go.svg",
-		"tags": ["apm"],
+		"tags": ["apm/traces"],
 		"module": "apm",
 		"relatedSearchKeywords": [
 			"apm",
@@ -761,7 +779,7 @@
 		"dataSource": "php",
 		"label": "PHP",
 		"imgUrl": "/Logos/php.svg",
-		"tags": ["apm"],
+		"tags": ["apm/traces"],
 		"module": "apm",
 		"relatedSearchKeywords": [
 			"apm",
@@ -784,7 +802,6 @@
 			"php zipkin tracing",
 			"otel php exporter",
 			"php http instrumentation",
-			"php prometheus exporter",
 			"php-fpm monitoring",
 			"php on kubernetes",
 			"php in containers",
@@ -829,7 +846,7 @@
 		"dataSource": "dotnet",
 		"label": ".NET",
 		"imgUrl": "/Logos/dotnet.svg",
-		"tags": ["apm"],
+		"tags": ["apm/traces"],
 		"module": "apm",
 		"relatedSearchKeywords": [
 			"apm",
@@ -861,7 +878,6 @@
 			".net kubernetes",
 			"dotnet in containers",
 			"opentelemetry exporter .net",
-			".net prometheus exporter",
 			"c# opentelemetry",
 			"monitor c# app",
 			"entity framework telemetry",
@@ -902,7 +918,7 @@
 		"dataSource": "ruby-on-rails",
 		"label": "Ruby on Rails",
 		"imgUrl": "/Logos/ruby-on-rails.svg",
-		"tags": ["apm"],
+		"tags": ["apm/traces"],
 		"module": "apm",
 		"relatedSearchKeywords": [
 			"apm",
@@ -967,7 +983,7 @@
 		"dataSource": "elixir",
 		"label": "Elixir",
 		"imgUrl": "/Logos/elixir.svg",
-		"tags": ["apm"],
+		"tags": ["apm/traces"],
 		"module": "apm",
 		"relatedSearchKeywords": [
 			"apm",
@@ -1026,7 +1042,7 @@
 		"dataSource": "rust",
 		"label": "Rust",
 		"imgUrl": "/Logos/rust.svg",
-		"tags": ["apm"],
+		"tags": ["apm/traces"],
 		"module": "apm",
 		"relatedSearchKeywords": [
 			"apm",
@@ -1079,7 +1095,7 @@
 		"dataSource": "swift",
 		"label": "Swift",
 		"imgUrl": "/Logos/swift.svg",
-		"tags": ["apm"],
+		"tags": ["apm/traces"],
 		"module": "apm",
 		"relatedSearchKeywords": [
 			"apm",
@@ -1110,7 +1126,6 @@
 			"urlsession instrumentation",
 			"ios sdk opentelemetry",
 			"apple ecosystem observability",
-			"swift prometheus exporter",
 			"ios otlp exporter",
 			"ios telemetry sdk"
 		],
@@ -1146,7 +1161,7 @@
 		"dataSource": "opentelemetry-cpp",
 		"label": "C++",
 		"imgUrl": "/Logos/cpp.svg",
-		"tags": ["apm"],
+		"tags": ["apm/traces"],
 		"module": "apm",
 		"relatedSearchKeywords": [
 			"apm",
@@ -1188,7 +1203,7 @@
 		"dataSource": "nginx-tracing",
 		"label": "Nginx - Tracing",
 		"imgUrl": "/Logos/nginx.svg",
-		"tags": ["apm"],
+		"tags": ["apm/traces"],
 		"module": "apm",
 		"relatedSearchKeywords": ["tracing", "nginx server", "nginx proxy", "nginx"],
 		"id": "nginx-tracing",
@@ -1198,7 +1213,7 @@
 		"dataSource": "opentelemetry-wordpress",
 		"label": "WordPress",
 		"imgUrl": "/Logos/wordpress.svg",
-		"tags": ["apm"],
+		"tags": ["apm/traces"],
 		"module": "apm",
 		"relatedSearchKeywords": [
 			"apm",
@@ -1224,7 +1239,7 @@
 		"dataSource": "opentelemetry-cloudflare",
 		"label": "Cloudflare",
 		"imgUrl": "/Logos/cloudflare.svg",
-		"tags": ["apm"],
+		"tags": ["apm/traces", "logs"],
 		"module": "apm",
 		"relatedSearchKeywords": [
 			"apm",
@@ -1541,7 +1556,7 @@
 	},
 	{
 		"dataSource": "from-log-file",
-		"label": "From Log File",
+		"label": "Collect Logs From Log File",
 		"imgUrl": "/Logos/from-log-file.svg",
 		"tags": ["logs"],
 		"module": "logs",
@@ -2656,6 +2671,170 @@
 		],
 		"link": "https://signoz.io/docs/community/llm-monitoring/"
 	},
+	{
+		"dataSource": "anthropic-api",
+		"label": "Anthropic API",
+		"imgUrl": "/Logos/anthropic-api-monitoring.svg",
+		"tags": ["LLM Monitoring"],
+		"module": "metrics",
+		"relatedSearchKeywords": [
+			"llm monitoring",
+			"large language model observability",
+			"monitor anthropic",
+			"llm response time tracing",
+			"llm metrics",
+			"otel llm integration",
+			"llm performance tracking",
+			"metrics",
+			"traces",
+			"logs"
+		],
+		"link": "https://signoz.io/docs/anthropic-monitoring/"
+	},
+	{
+		"dataSource": "claude-code",
+		"label": "Claude Code",
+		"imgUrl": "/Logos/claude-code.svg",
+		"tags": ["LLM Monitoring"],
+		"module": "metrics",
+		"relatedSearchKeywords": [
+			"claude code monitoring",
+			"claude code observability",
+			"claude code performance tracking",
+			"claude code latency tracing",
+			"claude code metrics",
+			"otel claude integration",
+			"claude code response time",
+			"claude code logs",
+			"claude code error tracking",
+			"claude code debugging",
+			"metrics",
+			"logs"
+		],
+		"link": "https://signoz.io/docs/claude-code-monitoring/"
+	},
+	{
+		"dataSource": "deepseek-api",
+		"label": "DeepSeek API",
+		"imgUrl": "/Logos/deepseek.svg",
+		"tags": ["LLM Monitoring"],
+		"module": "metrics",
+		"relatedSearchKeywords": [
+			"deepseek api monitoring",
+			"deepseek api observability",
+			"deepseek api performance tracking",
+			"deepseek api latency tracing",
+			"deepseek api metrics",
+			"otel deepseek integration",
+			"deepseek api response time",
+			"deepseek api logs",
+			"deepseek api error tracking",
+			"deepseek api debugging",
+			"metrics",
+			"logs"
+		],
+		"link": "https://signoz.io/docs/deepseek-monitoring/"
+	},
+	{
+		"dataSource": "google-gemini-api",
+		"label": "Google Gemini",
+		"imgUrl": "/Logos/google-gemini.svg",
+		"tags": ["LLM Monitoring"],
+		"module": "metrics",
+		"relatedSearchKeywords": [
+			"google gemini api monitoring",
+			"google gemini api observability",
+			"google gemini api performance tracking",
+			"google gemini api latency tracing",
+			"google gemini api metrics",
+			"otel google gemini integration",
+			"google gemini api response time",
+			"google gemini api logs",
+			"google gemini api error tracking",
+			"google gemini api debugging",
+			"gemini",
+			"metrics",
+			"logs"
+		],
+		"link": "https://signoz.io/docs/google-gemini-monitoring/"
+	},
+	{
+		"dataSource": "langchain",
+		"label": "LangChain",
+		"imgUrl": "/Logos/langchain.svg",
+		"tags": ["LLM Monitoring"],
+		"module": "apm",
+		"relatedSearchKeywords": [
+			"langchain monitoring",
+			"langchain observability",
+			"langchain performance tracking",
+			"langchain latency tracing",
+			"langchain metrics",
+			"otel langchain integration",
+			"langchain response time",
+			"langchain logs",
+			"langchain error tracking",
+			"langchain debugging",
+			"traces"
+		],
+		"link": "https://signoz.io/docs/langchain-monitoring/"
+	},
+	{
+		"dataSource": "llamaindex",
+		"label": "LlamaIndex",
+		"imgUrl": "/Logos/llamaindex.svg",
+		"tags": ["LLM Monitoring"],
+		"module": "apm",
+		"relatedSearchKeywords": [
+			"llamaindex monitoring",
+			"llamaindex observability",
+			"llamaindex performance tracking",
+			"llamaindex latency tracing",
+			"llamaindex metrics",
+			"otel llamaindex integration",
+			"llamaindex response time",
+			"llamaindex logs",
+			"llamaindex error tracking",
+			"llamaindex debugging",
+			"traces"
+		],
+		"link": "https://signoz.io/docs/llamaindex-monitoring/"
+	},
+	{
+		"dataSource": "vercel-ai-sdk",
+		"label": "Vercel AI SDK",
+		"imgUrl": "/Logos/vercel.svg",
+		"tags": ["LLM Monitoring"],
+		"module": "apm",
+		"relatedSearchKeywords": [
+			"vercel ai sdk monitoring",
+			"vercel ai sdk observability",
+			"vercel ai sdk performance tracking",
+			"vercel ai sdk latency tracing",
+			"vercel ai sdk metrics",
+			"otel vercel ai sdk integration",
+			"vercel ai sdk response time",
+			"vercel ai sdk logs",
+			"vercel ai sdk error tracking",
+			"vercel ai sdk debugging",
+			"traces"
+		],
+		"link": "https://signoz.io/docs/vercel-ai-sdk-monitoring/"
+	},
+	{
+		"dataSource": "mastra-monitoring",
+		"label": "Mastra",
+		"imgUrl": "/Logos/mastra.svg",
+		"tags": ["LLM Monitoring"],
+		"module": "apm",
+		"relatedSearchKeywords": [
+			"mastra monitoring",
+			"mastra observability",
+			"mastra agent",
+			"traces"
+		],
+		"link": "https://signoz.io/docs/mastra-monitoring/"
+	},
 	{
 		"dataSource": "http-endpoints-monitoring",
 		"label": "HTTP Endpoints Monitoring",
@@ -3391,5 +3570,58 @@
 				}
 			]
 		}
+	},
+	{
+		"dataSource": "microsoft-sql-server",
+		"label": "Microsoft SQL Server",
+		"imgUrl": "/Logos/microsoft-sql-server.svg",
+		"tags": ["integrations"],
+		"module": "metrics",
+		"relatedSearchKeywords": [
+			"sql server metrics",
+			"mssql monitoring",
+			"sql server performance",
+			"sql server observability",
+			"Microsoft",
+			"sql server logs",
+			"metrics",
+			"logs"
+		],
+		"id": "microsoft-sql-server",
+		"link": "https://signoz.io/docs/integrations/sql-server/"
+	},
+	{
+		"dataSource": "supabase",
+		"label": "Supabase",
+		"imgUrl": "/Logos/supabase.svg",
+		"tags": ["integrations"],
+		"module": "metrics",
+		"relatedSearchKeywords": [
+			"supabase metrics",
+			"supabase monitoring",
+			"supabase performance",
+			"supabase observability",
+			"supabase",
+			"metrics"
+			],
+		"id": "supabase",
+		"link": "https://signoz.io/docs/integrations/supabase/"
+	},
+	{
+		"dataSource": "nomad",
+		"label": "Nomad",
+		"imgUrl": "/Logos/nomad.svg",
+		"tags": ["integrations"],
+		"module": "metrics",
+		"relatedSearchKeywords": [
+			"nomad metrics",
+			"nomad monitoring",
+			"nomad performance",
+			"nomad observability",
+			"nomad",
+			"metrics"
+			],
+		"id": "nomad",
+		"link": "https://signoz.io/docs/integrations/nomad/"
 	}
 ]

frontend/src/container/OptionsMenu/useOptionsMenu.ts

@@ -1,3 +1,4 @@
+/* eslint-disable sonarjs/cognitive-complexity */
 import { getKeySuggestions } from 'api/querySuggestions/getKeySuggestions';
 import { TelemetryFieldKey } from 'api/v5/v5';
 import { AxiosResponse } from 'axios';
@@ -55,11 +56,10 @@ const useOptionsMenu = ({
 	initialOptions = {},
 }: UseOptionsMenuProps): UseOptionsMenu => {
 	const { notifications } = useNotifications();
-	const {
-		preferences,
-		updateColumns,
-		updateFormatting,
-	} = usePreferenceContext();
+	const prefCtx = usePreferenceContext();
+	// TODO: send null to updateColumns and updateFormatting if dataSource is not logs or traces
+	const slice = dataSource === DataSource.TRACES ? prefCtx.traces : prefCtx.logs;
+	const { preferences, updateColumns, updateFormatting } = slice;
 
 	const [searchText, setSearchText] = useState<string>('');
 	const [isFocused, setIsFocused] = useState<boolean>(false);

frontend/src/container/OrganizationSettings/AuthDomain/AuthDomain.styles.scss

@@ -0,0 +1,19 @@
+.auth-domain {
+	display: flex;
+	flex-direction: column;
+	gap: 8px;
+
+	.auth-domain-header {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+	}
+}
+
+.auth-domain-list {
+	.auth-domain-list-column-action {
+		display: flex;
+		flex-direction: row;
+		gap: 24px;
+	}
+}

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/AuthnProviderSelector.tsx

@@ -0,0 +1,90 @@
+import './CreateEdit.styles.scss';
+
+import { GoogleSquareFilled, KeyOutlined } from '@ant-design/icons';
+import { Button, Typography } from 'antd';
+
+interface AuthNProvider {
+	key: string;
+	title: string;
+	description: string;
+	icon: JSX.Element;
+	enabled: boolean;
+}
+
+function getAuthNProviders(samlEnabled: boolean): AuthNProvider[] {
+	return [
+		{
+			key: 'google_auth',
+			title: 'Google Apps Authentication',
+			description: 'Let members sign-in with a Google workspace account',
+			icon: <GoogleSquareFilled style={{ fontSize: '37px' }} />,
+			enabled: true,
+		},
+		{
+			key: 'saml',
+			title: 'SAML Authentication',
+			description:
+				'Azure, Active Directory, Okta or your custom SAML 2.0 solution',
+			icon: <KeyOutlined style={{ fontSize: '37px' }} />,
+			enabled: samlEnabled,
+		},
+
+		{
+			key: 'oidc',
+			title: 'OIDC Authentication',
+			description:
+				'Authenticate using OpenID Connect providers like Azure, Active Directory, Okta, or other OIDC compliant solutions',
+			icon: <KeyOutlined style={{ fontSize: '37px' }} />,
+			enabled: samlEnabled,
+		},
+	];
+}
+
+function AuthnProviderSelector({
+	setAuthnProvider,
+	samlEnabled,
+}: {
+	setAuthnProvider: React.Dispatch<React.SetStateAction<string>>;
+	samlEnabled: boolean;
+}): JSX.Element {
+	const authnProviders = getAuthNProviders(samlEnabled);
+	return (
+		<div className="authn-provider-selector">
+			<section className="header">
+				<Typography.Title level={4}>
+					Configure Authentication Method
+				</Typography.Title>
+				<Typography.Paragraph italic>
+					SigNoz supports the following single sign-on services (SSO). Get started
+					with setting your project’s SSO below
+				</Typography.Paragraph>
+			</section>
+			<section className="selector">
+				{authnProviders.map((provider) => {
+					if (provider.enabled) {
+						return (
+							<section key={provider.key} className="provider">
+								<span className="icon">{provider.icon}</span>
+								<div className="title-description">
+									<Typography.Text className="title">{provider.title}</Typography.Text>
+									<Typography.Paragraph className="description">
+										{provider.description}
+									</Typography.Paragraph>
+								</div>
+								<Button
+									onClick={(): void => setAuthnProvider(provider.key)}
+									type="primary"
+								>
+									Configure
+								</Button>
+							</section>
+						);
+					}
+					return <div key={provider.key} />;
+				})}
+			</section>
+		</div>
+	);
+}
+
+export default AuthnProviderSelector;

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/CreateEdit.styles.scss

@@ -0,0 +1,39 @@
+.authn-provider-selector {
+	display: flex;
+	flex-direction: column;
+
+	.header {
+		display: flex;
+		flex-direction: column;
+	}
+
+	.selector {
+		display: flex;
+		flex-direction: column;
+		gap: 16px;
+
+		.provider {
+			display: flex;
+			flex-direction: row;
+			align-items: center;
+			gap: 16px;
+
+			.title-description {
+				.title {
+					font-weight: bold;
+				}
+			}
+		}
+	}
+}
+
+.ant-modal-body {
+	.auth-domain-configure {
+		.action-buttons {
+			display: flex;
+			justify-content: end;
+			gap: 8px;
+			margin-top: 16px;
+		}
+	}
+}

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/CreateEdit.tsx

@@ -0,0 +1,134 @@
+import './CreateEdit.styles.scss';
+
+import { Button, Form, Modal } from 'antd';
+import put from 'api/v1/domains/id/put';
+import post from 'api/v1/domains/post';
+import { FeatureKeys } from 'constants/features';
+import { defaultTo } from 'lodash-es';
+import { useAppContext } from 'providers/App/App';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import { useState } from 'react';
+import APIError from 'types/api/error';
+import { GettableAuthDomain } from 'types/api/v1/domains/list';
+import { PostableAuthDomain } from 'types/api/v1/domains/post';
+
+import AuthnProviderSelector from './AuthnProviderSelector';
+import ConfigureGoogleAuthAuthnProvider from './Providers/AuthnGoogleAuth';
+import ConfigureOIDCAuthnProvider from './Providers/AuthnOIDC';
+import ConfigureSAMLAuthnProvider from './Providers/AuthnSAML';
+
+interface CreateOrEditProps {
+	isCreate: boolean;
+	onClose: () => void;
+	record?: GettableAuthDomain;
+}
+
+function configureAuthnProvider(
+	authnProvider: string,
+	isCreate: boolean,
+): JSX.Element {
+	switch (authnProvider) {
+		case 'saml':
+			return <ConfigureSAMLAuthnProvider isCreate={isCreate} />;
+		case 'google_auth':
+			return <ConfigureGoogleAuthAuthnProvider isCreate={isCreate} />;
+		case 'oidc':
+			return <ConfigureOIDCAuthnProvider isCreate={isCreate} />;
+		default:
+			return <ConfigureGoogleAuthAuthnProvider isCreate={isCreate} />;
+	}
+}
+
+function CreateOrEdit(props: CreateOrEditProps): JSX.Element {
+	const { isCreate, record, onClose } = props;
+	const [form] = Form.useForm<PostableAuthDomain>();
+	const [authnProvider, setAuthnProvider] = useState<string>(
+		record?.ssoType || '',
+	);
+
+	const { showErrorModal } = useErrorModal();
+	const { featureFlags } = useAppContext();
+	const samlEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.SSO)?.active || false;
+
+	const onSubmitHandler = async (): Promise<void> => {
+		const name = form.getFieldValue('name');
+		const googleAuthConfig = form.getFieldValue('googleAuthConfig');
+		const samlConfig = form.getFieldValue('samlConfig');
+		const oidcConfig = form.getFieldValue('oidcConfig');
+
+		try {
+			if (isCreate) {
+				await post({
+					name,
+					config: {
+						ssoEnabled: true,
+						ssoType: authnProvider,
+						googleAuthConfig,
+						samlConfig,
+						oidcConfig,
+					},
+				});
+			} else {
+				await put({
+					id: record?.id || '',
+					config: {
+						ssoEnabled: form.getFieldValue('ssoEnabled'),
+						ssoType: authnProvider,
+						googleAuthConfig,
+						samlConfig,
+						oidcConfig,
+					},
+				});
+			}
+
+			onClose();
+		} catch (error) {
+			showErrorModal(error as APIError);
+		}
+	};
+
+	const onBackHandler = (): void => {
+		setAuthnProvider('');
+	};
+
+	return (
+		<Modal open footer={null} onCancel={onClose}>
+			<Form
+				name="auth-domain"
+				initialValues={defaultTo(record, {
+					name: '',
+					ssoEnabled: false,
+					ssoType: '',
+				})}
+				form={form}
+				layout="vertical"
+			>
+				{isCreate && authnProvider === '' && (
+					<AuthnProviderSelector
+						setAuthnProvider={setAuthnProvider}
+						samlEnabled={samlEnabled}
+					/>
+				)}
+				{authnProvider !== '' && (
+					<div className="auth-domain-configure">
+						{configureAuthnProvider(authnProvider, isCreate)}
+						<section className="action-buttons">
+							{isCreate && <Button onClick={onBackHandler}>Back</Button>}
+							{!isCreate && <Button onClick={onClose}>Cancel</Button>}
+							<Button onClick={onSubmitHandler} type="primary">
+								Save Changes
+							</Button>
+						</section>
+					</div>
+				)}
+			</Form>
+		</Modal>
+	);
+}
+
+CreateOrEdit.defaultProps = {
+	record: null,
+};
+
+export default CreateOrEdit;

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/AuthnGoogleAuth.tsx

@@ -0,0 +1,68 @@
+import './Providers.styles.scss';
+
+import { Callout } from '@signozhq/callout';
+import { Form, Input, Typography } from 'antd';
+
+function ConfigureGoogleAuthAuthnProvider({
+	isCreate,
+}: {
+	isCreate: boolean;
+}): JSX.Element {
+	return (
+		<div className="google-auth">
+			<section className="header">
+				<Typography.Text className="title">
+					Edit Google Authentication
+				</Typography.Text>
+				<Typography.Paragraph className="description">
+					Enter OAuth 2.0 credentials obtained from the Google API Console below.
+					Read the{' '}
+					<a
+						href="https://signoz.io/docs/userguide/sso-authentication"
+						target="_blank"
+						rel="noreferrer"
+					>
+						docs
+					</a>{' '}
+					for more information.
+				</Typography.Paragraph>
+			</section>
+
+			<Form.Item label="Domain" name="name" className="field">
+				<Input disabled={!isCreate} />
+			</Form.Item>
+
+			<Form.Item
+				label="Client ID"
+				name={['googleAuthConfig', 'clientId']}
+				className="field"
+				tooltip={{
+					title: `ClientID is the application's ID. For example, 292085223830.apps.googleusercontent.com.`,
+				}}
+			>
+				<Input />
+			</Form.Item>
+
+			<Form.Item
+				label="Client Secret"
+				name={['googleAuthConfig', 'clientSecret']}
+				className="field"
+				tooltip={{
+					title: `It is the application's secret.`,
+				}}
+			>
+				<Input />
+			</Form.Item>
+
+			<Callout
+				type="warning"
+				size="small"
+				showIcon
+				description="Google OAuth2 won’t be enabled unless you enter all the attributes above"
+				className="callout"
+			/>
+		</div>
+	);
+}
+
+export default ConfigureGoogleAuthAuthnProvider;

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/AuthnOIDC.tsx

@@ -0,0 +1,105 @@
+import './Providers.styles.scss';
+
+import { Callout } from '@signozhq/callout';
+import { Checkbox, Form, Input, Typography } from 'antd';
+
+function ConfigureOIDCAuthnProvider({
+	isCreate,
+}: {
+	isCreate: boolean;
+}): JSX.Element {
+	return (
+		<div className="saml">
+			<section className="header">
+				<Typography.Text className="title">
+					Edit OIDC Authentication
+				</Typography.Text>
+			</section>
+
+			<Form.Item label="Domain" name="name">
+				<Input disabled={!isCreate} />
+			</Form.Item>
+
+			<Form.Item
+				label="Issuer URL"
+				name={['oidcConfig', 'issuer']}
+				tooltip={{
+					title: `It is the URL identifier for the service. For example: "https://accounts.google.com" or "https://login.salesforce.com".`,
+				}}
+			>
+				<Input />
+			</Form.Item>
+
+			<Form.Item
+				label="Issuer Alias"
+				name={['oidcConfig', 'issuerAlias']}
+				tooltip={{
+					title: `Some offspec providers like Azure, Oracle IDCS have oidc discovery url different from issuer url which causes issuerValidation to fail.
+					This provides a way to override the Issuer url from the .well-known/openid-configuration issuer`,
+				}}
+			>
+				<Input />
+			</Form.Item>
+
+			<Form.Item
+				label="Client ID"
+				name={['oidcConfig', 'clientId']}
+				tooltip={{ title: `It is the application's ID.` }}
+			>
+				<Input />
+			</Form.Item>
+
+			<Form.Item
+				label="Client Secret"
+				name={['oidcConfig', 'clientSecret']}
+				tooltip={{ title: `It is the application's secret.` }}
+			>
+				<Input />
+			</Form.Item>
+
+			<Form.Item
+				label="Email Claim Mapping"
+				name={['oidcConfig', 'claimMapping', 'email']}
+				tooltip={{
+					title: `Mapping of email claims to the corresponding email field in the token.`,
+				}}
+			>
+				<Input />
+			</Form.Item>
+
+			<Form.Item
+				label="Skip Email Verification"
+				name={['oidcConfig', 'insecureSkipEmailVerified']}
+				valuePropName="checked"
+				className="field"
+				tooltip={{
+					title: `Whether to skip email verification. Defaults to "false"`,
+				}}
+			>
+				<Checkbox />
+			</Form.Item>
+
+			<Form.Item
+				label="Get User Info"
+				name={['oidcConfig', 'getUserInfo']}
+				valuePropName="checked"
+				className="field"
+				tooltip={{
+					title: `Uses the userinfo endpoint to get additional claims for the token. This is especially useful where upstreams return "thin" id tokens`,
+				}}
+			>
+				<Checkbox />
+			</Form.Item>
+
+			<Callout
+				type="warning"
+				size="small"
+				showIcon
+				description="OIDC won’t be enabled unless you enter all the attributes above"
+				className="callout"
+			/>
+		</div>
+	);
+}
+
+export default ConfigureOIDCAuthnProvider;

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/AuthnSAML.tsx

@@ -0,0 +1,77 @@
+import './Providers.styles.scss';
+
+import { Callout } from '@signozhq/callout';
+import { Checkbox, Form, Input, Typography } from 'antd';
+
+function ConfigureSAMLAuthnProvider({
+	isCreate,
+}: {
+	isCreate: boolean;
+}): JSX.Element {
+	return (
+		<div className="saml">
+			<section className="header">
+				<Typography.Text className="title">
+					Edit SAML Authentication
+				</Typography.Text>
+			</section>
+
+			<Form.Item label="Domain" name="name">
+				<Input disabled={!isCreate} />
+			</Form.Item>
+
+			<Form.Item
+				label="SAML ACS URL"
+				name={['samlConfig', 'samlIdp']}
+				tooltip={{
+					title: `The entityID of the SAML identity provider. It can typically be found in the EntityID attribute of the EntityDescriptor element in the SAML metadata of the identity provider. Example: <md:EntityDescriptor xmlns:md="urn:oasis:names:tc:SAML:2.0:metadata" entityID="{samlEntity}">`,
+				}}
+			>
+				<Input />
+			</Form.Item>
+
+			<Form.Item
+				label="SAML Entity ID"
+				name={['samlConfig', 'samlEntity']}
+				tooltip={{
+					title: `The SSO endpoint of the SAML identity provider. It can typically be found in the SingleSignOnService element in the SAML metadata of the identity provider. Example: <md:SingleSignOnService Binding="urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST" Location="{samlIdp}"/>`,
+				}}
+			>
+				<Input />
+			</Form.Item>
+
+			<Form.Item
+				label="SAML X.509 Certificate"
+				name={['samlConfig', 'samlCert']}
+				tooltip={{
+					title: `The certificate of the SAML identity provider. It can typically be found in the X509Certificate element in the SAML metadata of the identity provider. Example: <ds:X509Certificate><ds:X509Certificate>{samlCert}</ds:X509Certificate></ds:X509Certificate>`,
+				}}
+			>
+				<Input.TextArea rows={4} />
+			</Form.Item>
+
+			<Form.Item
+				label="Skip Signing AuthN Requests"
+				name={['samlConfig', 'insecureSkipAuthNRequestsSigned']}
+				valuePropName="checked"
+				className="field"
+				tooltip={{
+					title: `Whether to skip signing the SAML requests. It can typically be found in the WantAuthnRequestsSigned attribute of the IDPSSODescriptor element in the SAML metadata of the identity provider. Example: <md:IDPSSODescriptor WantAuthnRequestsSigned="false" protocolSupportEnumeration="urn:oasis:names:tc:SAML:2.0:protocol">
+					For providers like jumpcloud, this should be set to true.Note: This is the reverse of WantAuthnRequestsSigned. If WantAuthnRequestsSigned is false, then InsecureSkipAuthNRequestsSigned should be true.`,
+				}}
+			>
+				<Checkbox />
+			</Form.Item>
+
+			<Callout
+				type="warning"
+				size="small"
+				showIcon
+				description="SAML won’t be enabled unless you enter all the attributes above"
+				className="callout"
+			/>
+		</div>
+	);
+}
+
+export default ConfigureSAMLAuthnProvider;

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/Providers.styles.scss

@@ -0,0 +1,67 @@
+.google-auth {
+	display: flex;
+	flex-direction: column;
+
+	.ant-form-item {
+		margin-bottom: 12px !important;
+	}
+
+	.header {
+		display: flex;
+		flex-direction: column;
+		gap: 4px;
+		margin-bottom: 12px;
+
+		.title {
+			font-weight: bold;
+		}
+
+		.description {
+			margin-bottom: 0px !important;
+		}
+	}
+
+	.callout {
+		margin-top: 16px;
+	}
+}
+
+.saml {
+	display: flex;
+	flex-direction: column;
+
+	.ant-form-item {
+		margin-bottom: 12px !important;
+	}
+
+	.header {
+		display: flex;
+		flex-direction: column;
+		gap: 4px;
+		margin-bottom: 12px;
+
+		.title {
+			font-weight: bold;
+		}
+	}
+
+	.field {
+		.ant-row {
+			display: flex;
+			flex-direction: row;
+			align-items: center;
+			flex-flow: nowrap;
+
+			.ant-col {
+				display: flex;
+				flex-grow: 1;
+				width: 100%;
+				padding: 0px;
+			}
+		}
+	}
+
+	.callout {
+		margin-top: 16px;
+	}
+}

frontend/src/container/OrganizationSettings/AuthDomain/Toggle.tsx

@@ -0,0 +1,45 @@
+import { Switch } from 'antd';
+import put from 'api/v1/domains/id/put';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import { useState } from 'react';
+import APIError from 'types/api/error';
+import { GettableAuthDomain } from 'types/api/v1/domains/list';
+
+function Toggle({ isDefaultChecked, record }: ToggleProps): JSX.Element {
+	const [isChecked, setIsChecked] = useState<boolean>(isDefaultChecked);
+	const [isLoading, setIsLoading] = useState<boolean>(false);
+	const { showErrorModal } = useErrorModal();
+
+	const onChangeHandler = async (checked: boolean): Promise<void> => {
+		setIsLoading(true);
+
+		try {
+			await put({
+				id: record.id,
+				config: {
+					ssoEnabled: checked,
+					ssoType: record.ssoType,
+					googleAuthConfig: record.googleAuthConfig,
+					oidcConfig: record.oidcConfig,
+					samlConfig: record.samlConfig,
+				},
+			});
+			setIsChecked(checked);
+		} catch (error) {
+			showErrorModal(error as APIError);
+		}
+
+		setIsLoading(false);
+	};
+
+	return (
+		<Switch loading={isLoading} checked={isChecked} onChange={onChangeHandler} />
+	);
+}
+
+interface ToggleProps {
+	isDefaultChecked: boolean;
+	record: GettableAuthDomain;
+}
+
+export default Toggle;

frontend/src/container/OrganizationSettings/AuthDomain/index.tsx

@@ -0,0 +1,148 @@
+import './AuthDomain.styles.scss';
+
+import { PlusOutlined } from '@ant-design/icons';
+import { Button, Table, Typography } from 'antd';
+import { ColumnsType } from 'antd/lib/table';
+import deleteDomain from 'api/v1/domains/id/delete';
+import listAllDomain from 'api/v1/domains/list';
+import ErrorContent from 'components/ErrorModal/components/ErrorContent';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import { useState } from 'react';
+import { useQuery } from 'react-query';
+import APIError from 'types/api/error';
+import { GettableAuthDomain, SSOType } from 'types/api/v1/domains/list';
+
+import CreateEdit from './CreateEdit/CreateEdit';
+import Toggle from './Toggle';
+
+const columns: ColumnsType<GettableAuthDomain> = [
+	{
+		title: 'Domain',
+		dataIndex: 'name',
+		key: 'name',
+		width: 100,
+		render: (val): JSX.Element => <Typography.Text>{val}</Typography.Text>,
+	},
+	{
+		title: 'Enforce SSO',
+		dataIndex: 'ssoEnabled',
+		key: 'ssoEnabled',
+		width: 80,
+		render: (value: boolean, record: GettableAuthDomain): JSX.Element => (
+			<Toggle isDefaultChecked={value} record={record} />
+		),
+	},
+	{
+		title: 'Action',
+		dataIndex: 'action',
+		key: 'action',
+		width: 100,
+		render: (_, record: GettableAuthDomain): JSX.Element => (
+			<section className="auth-domain-list-column-action">
+				<Typography.Link data-column-action="configure">
+					Configure {SSOType.get(record.ssoType)}
+				</Typography.Link>
+				<Typography.Link type="danger" data-column-action="delete">
+					Delete
+				</Typography.Link>
+			</section>
+		),
+	},
+];
+
+async function deleteDomainById(
+	id: string,
+	showErrorModal: (error: APIError) => void,
+	refetchAuthDomainListResponse: () => void,
+): Promise<void> {
+	try {
+		await deleteDomain(id);
+		refetchAuthDomainListResponse();
+	} catch (error) {
+		showErrorModal(error as APIError);
+	}
+}
+
+function AuthDomain(): JSX.Element {
+	const [record, setRecord] = useState<GettableAuthDomain>();
+	const [addDomain, setAddDomain] = useState<boolean>(false);
+	const { showErrorModal } = useErrorModal();
+	const {
+		data: authDomainListResponse,
+		isLoading: isLoadingAuthDomainListResponse,
+		isFetching: isFetchingAuthDomainListResponse,
+		error: errorFetchingAuthDomainListResponse,
+		refetch: refetchAuthDomainListResponse,
+	} = useQuery({
+		queryFn: listAllDomain,
+		queryKey: ['/api/v1/domains', 'list'],
+		enabled: true,
+	});
+
+	return (
+		<div className="auth-domain">
+			<section className="auth-domain-header">
+				<Typography.Title level={3}>Authenticated Domains</Typography.Title>
+				<Button
+					type="primary"
+					icon={<PlusOutlined />}
+					onClick={(): void => {
+						setAddDomain(true);
+					}}
+					className="button"
+				>
+					Add Domain
+				</Button>
+			</section>
+			{(errorFetchingAuthDomainListResponse as APIError) && (
+				<ErrorContent error={errorFetchingAuthDomainListResponse as APIError} />
+			)}
+			{!(errorFetchingAuthDomainListResponse as APIError) && (
+				<Table
+					columns={columns}
+					dataSource={authDomainListResponse?.data}
+					onRow={(record): any => ({
+						onClick: (
+							event: React.SyntheticEvent<HTMLLinkElement, MouseEvent>,
+						): void => {
+							const target = event.target as HTMLLinkElement;
+							const { columnAction } = target.dataset;
+							switch (columnAction) {
+								case 'configure':
+									setRecord(record);
+
+									break;
+								case 'delete':
+									deleteDomainById(
+										record.id,
+										showErrorModal,
+										refetchAuthDomainListResponse,
+									);
+									break;
+								default:
+									console.error('Unknown action:', columnAction);
+							}
+						},
+					})}
+					loading={
+						isLoadingAuthDomainListResponse || isFetchingAuthDomainListResponse
+					}
+					className="auth-domain-list"
+				/>
+			)}
+			{(addDomain || record) && (
+				<CreateEdit
+					isCreate={!record}
+					record={record}
+					onClose={(): void => {
+						setAddDomain(false);
+						setRecord(undefined);
+						refetchAuthDomainListResponse();
+					}}
+				/>
+			)}
+		</div>
+	);
+}
+
+export default AuthDomain;

frontend/src/container/OrganizationSettings/AuthDomains/AddDomain/index.tsx

@@ -1,101 +0,0 @@
-/* eslint-disable prefer-regex-literals */
-import { PlusOutlined } from '@ant-design/icons';
-import { Button, Form, Input, Modal, Typography } from 'antd';
-import { useForm } from 'antd/es/form/Form';
-import createDomainApi from 'api/v1/domains/create';
-import { useNotifications } from 'hooks/useNotifications';
-import { useAppContext } from 'providers/App/App';
-import { useState } from 'react';
-import { useTranslation } from 'react-i18next';
-import APIError from 'types/api/error';
-
-function AddDomain({ refetch }: Props): JSX.Element {
-	const { t } = useTranslation(['common', 'organizationsettings']);
-	const [isAddDomains, setIsDomain] = useState(false);
-	const [form] = useForm<FormProps>();
-	const { org } = useAppContext();
-
-	const { notifications } = useNotifications();
-
-	const onCreateHandler = async (): Promise<void> => {
-		try {
-			await createDomainApi({
-				name: form.getFieldValue('domain'),
-				orgId: (org || [])[0].id,
-			});
-
-			notifications.success({
-				message: 'Your domain has been added successfully.',
-				duration: 15,
-			});
-			setIsDomain(false);
-			refetch();
-		} catch (error) {
-			notifications.error({
-				message: (error as APIError).getErrorCode(),
-				description: (error as APIError).getErrorMessage(),
-			});
-		}
-	};
-
-	return (
-		<>
-			<div className="auth-domains-title-container">
-				<Typography.Title level={3}>
-					{t('authenticated_domains', {
-						ns: 'organizationsettings',
-					})}
-				</Typography.Title>
-				<Button
-					onClick={(): void => setIsDomain(true)}
-					type="primary"
-					icon={<PlusOutlined />}
-				>
-					{t('add_domain', { ns: 'organizationsettings' })}
-				</Button>
-			</div>
-			<Modal
-				centered
-				title="Add Domain"
-				className="add-domain-modal"
-				footer={null}
-				open={isAddDomains}
-				destroyOnClose
-				onCancel={(): void => setIsDomain(false)}
-			>
-				<Form form={form} onFinish={onCreateHandler} requiredMark>
-					<Form.Item
-						required
-						name={['domain']}
-						rules={[
-							{
-								message: 'Please enter a valid domain',
-								required: true,
-								pattern: new RegExp(
-									'^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$',
-								),
-							},
-						]}
-					>
-						<Input placeholder="signoz.io" />
-					</Form.Item>
-					<Form.Item>
-						<Button type="primary" htmlType="submit">
-							Add Domain
-						</Button>
-					</Form.Item>
-				</Form>
-			</Modal>
-		</>
-	);
-}
-
-interface FormProps {
-	domain: string;
-}
-
-interface Props {
-	refetch: () => void;
-}
-
-export default AddDomain;

frontend/src/container/OrganizationSettings/AuthDomains/Create/Row/index.tsx

@@ -1,39 +0,0 @@
-import { Button, Space, Typography } from 'antd';
-import { ReactNode } from 'react';
-
-import { IconContainer, TitleContainer, TitleText } from './styles';
-
-function Row({
-	onClickHandler,
-	Icon,
-	buttonText,
-	subTitle,
-	title,
-	isDisabled,
-}: RowProps): JSX.Element {
-	return (
-		<Space style={{ justifyContent: 'space-between', width: '100%' }}>
-			<IconContainer>{Icon}</IconContainer>
-
-			<TitleContainer>
-				<TitleText>{title}</TitleText>
-				<Typography.Text>{subTitle}</Typography.Text>
-			</TitleContainer>
-
-			<Button disabled={isDisabled} onClick={onClickHandler} type="primary">
-				{buttonText}
-			</Button>
-		</Space>
-	);
-}
-
-export interface RowProps {
-	onClickHandler: VoidFunction;
-	Icon: ReactNode;
-	title: string;
-	subTitle: ReactNode;
-	buttonText: string;
-	isDisabled: boolean;
-}
-
-export default Row;

frontend/src/container/OrganizationSettings/AuthDomains/Create/Row/styles.ts

@@ -1,16 +0,0 @@
-import { Typography } from 'antd';
-import styled from 'styled-components';
-
-export const TitleContainer = styled.div`
-	display: flex;
-	flex-direction: column;
-	gap: 0.25rem;
-`;
-
-export const IconContainer = styled.div`
-	min-width: 70px;
-`;
-
-export const TitleText = styled(Typography)`
-	font-weight: bold;
-`;

frontend/src/container/OrganizationSettings/AuthDomains/Create/index.tsx

@@ -1,118 +0,0 @@
-import { GoogleSquareFilled, KeyOutlined } from '@ant-design/icons';
-import { Typography } from 'antd';
-import { FeatureKeys } from 'constants/features';
-import { useAppContext } from 'providers/App/App';
-import { useCallback, useMemo } from 'react';
-import { AuthDomain, GOOGLE_AUTH, SAML } from 'types/api/SAML/listDomain';
-
-import Row, { RowProps } from './Row';
-import { RowContainer, RowSpace } from './styles';
-
-function Create({
-	ssoMethod,
-	assignSsoMethod,
-	setIsSettingsOpen,
-	setIsEditModalOpen,
-}: CreateProps): JSX.Element {
-	const { featureFlags } = useAppContext();
-	const SSOFlag =
-		featureFlags?.find((flag) => flag.name === FeatureKeys.SSO)?.active || false;
-
-	const onGoogleAuthClickHandler = useCallback(() => {
-		assignSsoMethod(GOOGLE_AUTH);
-		setIsSettingsOpen(false);
-		setIsEditModalOpen(true);
-	}, [assignSsoMethod, setIsSettingsOpen, setIsEditModalOpen]);
-
-	const onEditSAMLHandler = useCallback(() => {
-		assignSsoMethod(SAML);
-		setIsSettingsOpen(false);
-		setIsEditModalOpen(true);
-	}, [assignSsoMethod, setIsSettingsOpen, setIsEditModalOpen]);
-
-	const ConfigureButtonText = useMemo(() => {
-		switch (ssoMethod) {
-			case GOOGLE_AUTH:
-				return 'Edit Google Auth';
-			case SAML:
-				return 'Edit SAML';
-			default:
-				return 'Get Started';
-		}
-	}, [ssoMethod]);
-
-	const data: RowProps[] = SSOFlag
-		? [
-				{
-					buttonText: ConfigureButtonText,
-					Icon: <GoogleSquareFilled style={{ fontSize: '37px' }} />,
-					title: 'Google Apps Authentication',
-					subTitle: 'Let members sign-in with a Google workspace account',
-					onClickHandler: onGoogleAuthClickHandler,
-					isDisabled: false,
-				},
-				{
-					buttonText: ConfigureButtonText,
-					Icon: <KeyOutlined style={{ fontSize: '37px' }} />,
-					onClickHandler: onEditSAMLHandler,
-					subTitle: (
-						<>
-							Azure, Active Directory, Okta or your custom SAML 2.0 solution{' '}
-							<a
-								href="https://github.com/SigNoz/signoz/issues/8647"
-								target="_blank"
-								rel="noopener noreferrer"
-							>
-								(Unsupported SAMLs)
-							</a>
-						</>
-					),
-					title: 'SAML Authentication',
-					isDisabled: false,
-				},
-		  ]
-		: [
-				{
-					buttonText: ConfigureButtonText,
-					Icon: <GoogleSquareFilled style={{ fontSize: '37px' }} />,
-					title: 'Google Apps Authentication',
-					subTitle: 'Let members sign-in with a Google account',
-					onClickHandler: onGoogleAuthClickHandler,
-					isDisabled: false,
-				},
-		  ];
-
-	return (
-		<div>
-			<Typography.Text italic>
-				SigNoz supports the following single sign-on services (SSO). Get started
-				with setting your project’s SSO below
-			</Typography.Text>
-
-			<RowContainer>
-				<RowSpace direction="vertical">
-					{data.map((rowData) => (
-						<Row
-							Icon={rowData.Icon}
-							buttonText={rowData.buttonText}
-							onClickHandler={rowData.onClickHandler}
-							subTitle={rowData.subTitle}
-							title={rowData.title}
-							key={rowData.title}
-							isDisabled={rowData.isDisabled}
-						/>
-					))}
-				</RowSpace>
-			</RowContainer>
-		</div>
-	);
-}
-
-interface CreateProps {
-	ssoMethod: AuthDomain['ssoType'];
-	assignSsoMethod: (value: AuthDomain['ssoType']) => void;
-	setIsSettingsOpen: (value: boolean) => void;
-	setIsEditModalOpen: (value: boolean) => void;
-}
-
-export default Create;