fix: remove dead code

### Summary

- return display name instead of name for organization

.devenv/docker/postgres/compose.yaml

@@ -0,0 +1,27 @@
+services:
+
+  postgres:
+    image: postgres:15
+    container_name: postgres
+    environment:
+      POSTGRES_DB: signoz
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: password
+    healthcheck:
+      test:
+        [
+          "CMD",
+          "pg_isready",
+          "-d",
+          "signoz",
+          "-U",
+          "postgres"
+        ]
+      interval: 30s
+      timeout: 30s
+      retries: 3
+    restart: on-failure
+    ports:
+      - "127.0.0.1:5432:5432/tcp"
+    volumes:
+      - ${PWD}/fs/tmp/var/lib/postgresql/data/:/var/lib/postgresql/data/

.github/workflows/README.md

@@ -1,42 +0,0 @@
-# Github actions
-
-## Testing the UI manually on each PR
-
-First we need to make sure the UI is ready
-* Check the `Start tunnel` step in `e2e-k8s/deploy-on-k3s-cluster` job and make sure you see `your url is: https://pull-<number>-signoz.loca.lt`
-* This job will run until the PR is merged or closed to keep the local tunneling alive
-    - github will cancel this job if the PR wasn't merged after 6h
-    - if the job was cancel, go to the action and press `Re-run all jobs`
-
-Now you can open your browser at https://pull-<number>-signoz.loca.lt and check the UI.
-
-##  Environment Variables
-
-To run GitHub workflow, a few environment variables needs to add in GitHub secrets
-
-<table>
-  <tr>
-    <th> Variables </th>
-    <th> Description </th>
-    <th> Example </th>
-  </tr>
-  <tr>
-    <td> REPONAME </td>
-    <td> Provide the DockerHub user/organisation name of the image. </td>
-    <td> signoz</td>
-  </tr>
-  <tr>
-    <td> DOCKERHUB_USERNAME </td>
-    <td> Docker hub username </td>
-    <td> signoz</td>
-  </tr>
-  <tr>
-    <td> DOCKERHUB_TOKEN </td>
-    <td> Docker hub password/token with push permission </td>
-    <td> **** </td>
-  </tr>
-  <tr>
-    <td> SONAR_TOKEN </td>
-    <td> <a href="https://sonarcloud.io">SonarCloud</a> token </td>
-    <td> **** </td>
-  </tr>

.github/workflows/integrationci.yaml

@@ -44,10 +44,8 @@ jobs:
       - name: run
         run: |
           cd tests/integration && \
-            poetry run pytest -ra \
+            poetry run pytest \
             --basetemp=./tmp/ \
-            -vv \
-            --capture=no \
             src/${{matrix.src}} \
             --sqlstore-provider ${{matrix.sqlstore-provider}} \
             --postgres-version ${{matrix.postgres-version}} \

.github/workflows/remove-label.yaml

@@ -1,16 +0,0 @@
-name: remove-label
-
-on:
-  pull_request_target:
-    types: [synchronize]
-
-jobs:
-  remove:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Remove label testing-deploy from PR
-        uses: buildsville/add-remove-label@v2.0.0
-        with:
-          label: testing-deploy
-          type: remove
-          token: ${{ secrets.GITHUB_TOKEN }}

Makefile

@@ -56,6 +56,11 @@ devenv-clickhouse: ## Run clickhouse in devenv
 	@cd .devenv/docker/clickhouse; \
 	docker compose -f compose.yaml up -d
 
+.PHONY: devenv-postgres
+devenv-postgres: ## Run postgres in devenv
+	@cd .devenv/docker/postgres; \
+	docker compose -f compose.yaml up -d
+
 ##############################################################
 # go commands
 ##############################################################

conf/example.yaml

@@ -103,6 +103,13 @@ telemetrystore:
   clickhouse:
     # The DSN to use for clickhouse.
     dsn: tcp://localhost:9000
+    # The query settings for clickhouse.
+    settings:
+      max_execution_time: 0
+      max_execution_time_leaf: 0
+      timeout_before_checking_execution_speed: 0
+      max_bytes_to_read: 0
+      max_result_rows_for_ch_query: 0
 
 ##################### Prometheus #####################
 prometheus:

ee/http/middleware/pat.go

@@ -61,11 +61,17 @@ func (p *Pat) Wrap(next http.Handler) http.Handler {
 			return
 		}
 
+		role, err := authtypes.NewRole(user.Role)
+		if err != nil {
+			next.ServeHTTP(w, r)
+			return
+		}
+
 		jwt := authtypes.Claims{
-			UserID:  user.ID,
-			GroupID: user.GroupID,
-			Email:   user.Email,
-			OrgID:   user.OrgID,
+			UserID: user.ID,
+			Role:   role,
+			Email:  user.Email,
+			OrgID:  user.OrgID,
 		}
 
 		ctx = authtypes.NewContextWithClaims(ctx, jwt)

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

@@ -12,8 +12,7 @@ import (
 	"github.com/SigNoz/signoz/ee/query-service/usage"
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/apis/fields"
-	"github.com/SigNoz/signoz/pkg/modules/preference"
-	preferencecore "github.com/SigNoz/signoz/pkg/modules/preference/core"
+	"github.com/SigNoz/signoz/pkg/http/middleware"
 	baseapp "github.com/SigNoz/signoz/pkg/query-service/app"
 	"github.com/SigNoz/signoz/pkg/query-service/app/cloudintegrations"
 	"github.com/SigNoz/signoz/pkg/query-service/app/integrations"
@@ -24,14 +23,12 @@ import (
 	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/types/preferencetypes"
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/gorilla/mux"
 )
 
 type APIHandlerOptions struct {
 	DataConnector                 interfaces.DataConnector
-	SkipConfig                    *basemodel.SkipConfig
 	PreferSpanMetrics             bool
 	AppDao                        dao.ModelDao
 	RulesManager                  *rules.Manager
@@ -58,11 +55,8 @@ type APIHandler struct {
 
 // NewAPIHandler returns an APIHandler
 func NewAPIHandler(opts APIHandlerOptions, signoz *signoz.SigNoz) (*APIHandler, error) {
-	preference := preference.NewAPI(preferencecore.NewPreference(preferencecore.NewStore(signoz.SQLStore), preferencetypes.NewDefaultPreferenceMap()))
-
 	baseHandler, err := baseapp.NewAPIHandler(baseapp.APIHandlerOpts{
 		Reader:                        opts.DataConnector,
-		SkipConfig:                    opts.SkipConfig,
 		PreferSpanMetrics:             opts.PreferSpanMetrics,
 		AppDao:                        opts.AppDao,
 		RuleManager:                   opts.RulesManager,
@@ -72,12 +66,9 @@ func NewAPIHandler(opts APIHandlerOptions, signoz *signoz.SigNoz) (*APIHandler,
 		LogsParsingPipelineController: opts.LogsParsingPipelineController,
 		Cache:                         opts.Cache,
 		FluxInterval:                  opts.FluxInterval,
-		UseLogsNewSchema:              opts.UseLogsNewSchema,
-		UseTraceNewSchema:             opts.UseTraceNewSchema,
 		AlertmanagerAPI:               alertmanager.NewAPI(signoz.Alertmanager),
 		FieldsAPI:                     fields.NewAPI(signoz.TelemetryStore),
 		Signoz:                        signoz,
-		Preference:                    preference,
 	})
 
 	if err != nil {
@@ -121,7 +112,7 @@ func (ah *APIHandler) CheckFeature(f string) bool {
 }
 
 // RegisterRoutes registers routes for this handler on the given router
-func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *baseapp.AuthMiddleware) {
+func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	// note: add ee override methods first
 
 	// routes available only in ee version
@@ -194,7 +185,7 @@ func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *baseapp.AuthMiddlew
 
 }
 
-func (ah *APIHandler) RegisterCloudIntegrationsRoutes(router *mux.Router, am *baseapp.AuthMiddleware) {
+func (ah *APIHandler) RegisterCloudIntegrationsRoutes(router *mux.Router, am *middleware.AuthZ) {
 
 	ah.APIHandler.RegisterCloudIntegrationsRoutes(router, am)
 

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

@@ -134,7 +134,7 @@ func (ah *APIHandler) registerUser(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 
-		_, registerError := baseauth.Register(ctx, req, ah.Signoz.Alertmanager)
+		_, registerError := baseauth.Register(ctx, req, ah.Signoz.Alertmanager, ah.Signoz.Modules.Organization)
 		if !registerError.IsNil() {
 			RespondError(w, apierr, nil)
 			return
@@ -151,9 +151,8 @@ func (ah *APIHandler) registerUser(w http.ResponseWriter, r *http.Request) {
 func (ah *APIHandler) getInvite(w http.ResponseWriter, r *http.Request) {
 	token := mux.Vars(r)["token"]
 	sourceUrl := r.URL.Query().Get("ref")
-	ctx := context.Background()
 
-	inviteObject, err := baseauth.GetInvite(context.Background(), token)
+	inviteObject, err := baseauth.GetInvite(r.Context(), token, ah.Signoz.Modules.Organization)
 	if err != nil {
 		RespondError(w, model.BadRequest(err), nil)
 		return
@@ -163,7 +162,7 @@ func (ah *APIHandler) getInvite(w http.ResponseWriter, r *http.Request) {
 		InvitationResponseObject: inviteObject,
 	}
 
-	precheck, apierr := ah.AppDao().PrecheckLogin(ctx, inviteObject.Email, sourceUrl)
+	precheck, apierr := ah.AppDao().PrecheckLogin(r.Context(), inviteObject.Email, sourceUrl)
 	resp.Precheck = precheck
 
 	if apierr != nil {

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

@@ -12,11 +12,11 @@ import (
 
 	"github.com/SigNoz/signoz/ee/query-service/constants"
 	eeTypes "github.com/SigNoz/signoz/ee/types"
+	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/query-service/auth"
-	baseconstants "github.com/SigNoz/signoz/pkg/query-service/constants"
-	"github.com/SigNoz/signoz/pkg/query-service/dao"
 	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
 	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/google/uuid"
 	"github.com/gorilla/mux"
 	"go.uber.org/zap"
@@ -30,6 +30,12 @@ type CloudIntegrationConnectionParamsResponse struct {
 }
 
 func (ah *APIHandler) CloudIntegrationsGenerateConnectionParams(w http.ResponseWriter, r *http.Request) {
+	claims, err := authtypes.ClaimsFromContext(r.Context())
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
+
 	cloudProvider := mux.Vars(r)["cloudProvider"]
 	if cloudProvider != "aws" {
 		RespondError(w, basemodel.BadRequest(fmt.Errorf(
@@ -38,15 +44,7 @@ func (ah *APIHandler) CloudIntegrationsGenerateConnectionParams(w http.ResponseW
 		return
 	}
 
-	currentUser, err := auth.GetUserFromReqContext(r.Context())
-	if err != nil {
-		RespondError(w, basemodel.UnauthorizedError(fmt.Errorf(
-			"couldn't deduce current user: %w", err,
-		)), nil)
-		return
-	}
-
-	apiKey, apiErr := ah.getOrCreateCloudIntegrationPAT(r.Context(), currentUser.OrgID, cloudProvider)
+	apiKey, apiErr := ah.getOrCreateCloudIntegrationPAT(r.Context(), claims.OrgID, cloudProvider)
 	if apiErr != nil {
 		RespondError(w, basemodel.WrapApiError(
 			apiErr, "couldn't provision PAT for cloud integration:",
@@ -137,7 +135,7 @@ func (ah *APIHandler) getOrCreateCloudIntegrationPAT(ctx context.Context, orgId
 
 	newPAT := eeTypes.NewGettablePAT(
 		integrationPATName,
-		baseconstants.ViewerGroup,
+		authtypes.RoleViewer.String(),
 		integrationUser.ID,
 		0,
 	)
@@ -181,11 +179,7 @@ func (ah *APIHandler) getOrCreateCloudIntegrationUser(
 		OrgID: orgId,
 	}
 
-	viewerGroup, apiErr := dao.DB().GetGroupByName(ctx, baseconstants.ViewerGroup)
-	if apiErr != nil {
-		return nil, basemodel.WrapApiError(apiErr, "couldn't get viewer group for creating integration user")
-	}
-	newUser.GroupID = viewerGroup.ID
+	newUser.Role = authtypes.RoleViewer.String()
 
 	passwordHash, err := auth.PasswordHash(uuid.NewString())
 	if err != nil {

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

@@ -7,7 +7,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/query-service/app/dashboards"
-	"github.com/SigNoz/signoz/pkg/query-service/auth"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/gorilla/mux"
 )
@@ -36,18 +35,19 @@ func (ah *APIHandler) lockUnlockDashboard(w http.ResponseWriter, r *http.Request
 		return
 	}
 
-	claims, ok := authtypes.ClaimsFromContext(r.Context())
-	if !ok {
+	claims, err := authtypes.ClaimsFromContext(r.Context())
+	if err != nil {
 		render.Error(w, errors.Newf(errors.TypeUnauthenticated, errors.CodeUnauthenticated, "unauthenticated"))
 		return
 	}
+
 	dashboard, err := dashboards.GetDashboard(r.Context(), claims.OrgID, uuid)
 	if err != nil {
 		render.Error(w, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to get dashboard"))
 		return
 	}
 
-	if !auth.IsAdminV2(claims) && (dashboard.CreatedBy != claims.Email) {
+	if err := claims.IsAdmin(); err != nil && (dashboard.CreatedBy != claims.Email) {
 		render.Error(w, errors.Newf(errors.TypeForbidden, errors.CodeForbidden, "You are not authorized to lock/unlock this dashboard"))
 		return
 	}

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

@@ -1,7 +1,6 @@
 package api
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
@@ -13,35 +12,31 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	errorsV2 "github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/query-service/auth"
-	baseconstants "github.com/SigNoz/signoz/pkg/query-service/constants"
 	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
 	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/gorilla/mux"
 	"go.uber.org/zap"
 )
 
 func (ah *APIHandler) createPAT(w http.ResponseWriter, r *http.Request) {
-	ctx := context.Background()
+	claims, err := authtypes.ClaimsFromContext(r.Context())
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
 
 	req := model.CreatePATRequestBody{}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		RespondError(w, model.BadRequest(err), nil)
 		return
 	}
-	user, err := auth.GetUserFromReqContext(r.Context())
-	if err != nil {
-		RespondError(w, &model.ApiError{
-			Typ: model.ErrorUnauthorized,
-			Err: err,
-		}, nil)
-		return
-	}
+
 	pat := eeTypes.NewGettablePAT(
 		req.Name,
 		req.Role,
-		user.ID,
+		claims.UserID,
 		req.ExpiresInDays,
 	)
 	err = validatePATRequest(pat)
@@ -52,7 +47,7 @@ func (ah *APIHandler) createPAT(w http.ResponseWriter, r *http.Request) {
 
 	zap.L().Info("Got Create PAT request", zap.Any("pat", pat))
 	var apierr basemodel.BaseApiError
-	if pat, apierr = ah.AppDao().CreatePAT(ctx, user.OrgID, pat); apierr != nil {
+	if pat, apierr = ah.AppDao().CreatePAT(r.Context(), claims.OrgID, pat); apierr != nil {
 		RespondError(w, apierr, nil)
 		return
 	}
@@ -61,20 +56,28 @@ func (ah *APIHandler) createPAT(w http.ResponseWriter, r *http.Request) {
 }
 
 func validatePATRequest(req eeTypes.GettablePAT) error {
-	if req.Role == "" || (req.Role != baseconstants.ViewerGroup && req.Role != baseconstants.EditorGroup && req.Role != baseconstants.AdminGroup) {
-		return fmt.Errorf("valid role is required")
+	_, err := authtypes.NewRole(req.Role)
+	if err != nil {
+		return err
 	}
+
 	if req.ExpiresAt < 0 {
 		return fmt.Errorf("valid expiresAt is required")
 	}
+
 	if req.Name == "" {
 		return fmt.Errorf("valid name is required")
 	}
+
 	return nil
 }
 
 func (ah *APIHandler) updatePAT(w http.ResponseWriter, r *http.Request) {
-	ctx := context.Background()
+	claims, err := authtypes.ClaimsFromContext(r.Context())
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
 
 	req := eeTypes.GettablePAT{}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
@@ -89,24 +92,15 @@ func (ah *APIHandler) updatePAT(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	user, err := auth.GetUserFromReqContext(r.Context())
-	if err != nil {
-		RespondError(w, &model.ApiError{
-			Typ: model.ErrorUnauthorized,
-			Err: err,
-		}, nil)
-		return
-	}
-
 	//get the pat
-	existingPAT, paterr := ah.AppDao().GetPATByID(ctx, user.OrgID, id)
+	existingPAT, paterr := ah.AppDao().GetPATByID(r.Context(), claims.OrgID, id)
 	if paterr != nil {
 		render.Error(w, errorsV2.Newf(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, paterr.Error()))
 		return
 	}
 
 	// get the user
-	createdByUser, usererr := ah.AppDao().GetUser(ctx, existingPAT.UserID)
+	createdByUser, usererr := ah.AppDao().GetUser(r.Context(), existingPAT.UserID)
 	if usererr != nil {
 		render.Error(w, errorsV2.Newf(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, usererr.Error()))
 		return
@@ -123,11 +117,11 @@ func (ah *APIHandler) updatePAT(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	req.UpdatedByUserID = user.ID
+	req.UpdatedByUserID = claims.UserID
 	req.UpdatedAt = time.Now()
 	zap.L().Info("Got Update PAT request", zap.Any("pat", req))
 	var apierr basemodel.BaseApiError
-	if apierr = ah.AppDao().UpdatePAT(ctx, user.OrgID, req, id); apierr != nil {
+	if apierr = ah.AppDao().UpdatePAT(r.Context(), claims.OrgID, req, id); apierr != nil {
 		RespondError(w, apierr, nil)
 		return
 	}
@@ -136,50 +130,44 @@ func (ah *APIHandler) updatePAT(w http.ResponseWriter, r *http.Request) {
 }
 
 func (ah *APIHandler) getPATs(w http.ResponseWriter, r *http.Request) {
-	ctx := context.Background()
-	user, err := auth.GetUserFromReqContext(r.Context())
+	claims, err := authtypes.ClaimsFromContext(r.Context())
 	if err != nil {
-		RespondError(w, &model.ApiError{
-			Typ: model.ErrorUnauthorized,
-			Err: err,
-		}, nil)
+		render.Error(w, err)
 		return
 	}
-	zap.L().Info("Get PATs for user", zap.String("user_id", user.ID))
-	pats, apierr := ah.AppDao().ListPATs(ctx, user.OrgID)
+
+	pats, apierr := ah.AppDao().ListPATs(r.Context(), claims.OrgID)
 	if apierr != nil {
 		RespondError(w, apierr, nil)
 		return
 	}
+
 	ah.Respond(w, pats)
 }
 
 func (ah *APIHandler) revokePAT(w http.ResponseWriter, r *http.Request) {
-	ctx := context.Background()
+	claims, err := authtypes.ClaimsFromContext(r.Context())
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
+
 	idStr := mux.Vars(r)["id"]
 	id, err := valuer.NewUUID(idStr)
 	if err != nil {
 		render.Error(w, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
 		return
 	}
-	user, err := auth.GetUserFromReqContext(r.Context())
-	if err != nil {
-		RespondError(w, &model.ApiError{
-			Typ: model.ErrorUnauthorized,
-			Err: err,
-		}, nil)
-		return
-	}
 
 	//get the pat
-	existingPAT, paterr := ah.AppDao().GetPATByID(ctx, user.OrgID, id)
+	existingPAT, paterr := ah.AppDao().GetPATByID(r.Context(), claims.OrgID, id)
 	if paterr != nil {
 		render.Error(w, errorsV2.Newf(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, paterr.Error()))
 		return
 	}
 
 	// get the user
-	createdByUser, usererr := ah.AppDao().GetUser(ctx, existingPAT.UserID)
+	createdByUser, usererr := ah.AppDao().GetUser(r.Context(), existingPAT.UserID)
 	if usererr != nil {
 		render.Error(w, errorsV2.Newf(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, usererr.Error()))
 		return
@@ -191,7 +179,7 @@ func (ah *APIHandler) revokePAT(w http.ResponseWriter, r *http.Request) {
 	}
 
 	zap.L().Info("Revoke PAT with id", zap.String("id", id.StringValue()))
-	if apierr := ah.AppDao().RevokePAT(ctx, user.OrgID, id, user.ID); apierr != nil {
+	if apierr := ah.AppDao().RevokePAT(r.Context(), claims.OrgID, id, claims.UserID); apierr != nil {
 		RespondError(w, apierr, nil)
 		return
 	}

ee/query-service/app/db/reader.go

@@ -23,12 +23,10 @@ func NewDataConnector(
 	telemetryStore telemetrystore.TelemetryStore,
 	prometheus prometheus.Prometheus,
 	cluster string,
-	useLogsNewSchema bool,
-	useTraceNewSchema bool,
 	fluxIntervalForTraceDetail time.Duration,
 	cache cache.Cache,
 ) *ClickhouseReader {
-	chReader := basechr.NewReader(sqlDB, telemetryStore, prometheus, cluster, useLogsNewSchema, useTraceNewSchema, fluxIntervalForTraceDetail, cache)
+	chReader := basechr.NewReader(sqlDB, telemetryStore, prometheus, cluster, fluxIntervalForTraceDetail, cache)
 	return &ClickhouseReader{
 		conn:             telemetryStore.ClickhouseDB(),
 		appdb:            sqlDB,

ee/query-service/app/server.go

@@ -2,7 +2,6 @@ package app
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"net"
 	"net/http"
@@ -22,11 +21,9 @@ import (
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/SigNoz/signoz/pkg/query-service/auth"
 	"github.com/SigNoz/signoz/pkg/signoz"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/web"
 	"github.com/rs/cors"
@@ -48,33 +45,23 @@ import (
 	baseconst "github.com/SigNoz/signoz/pkg/query-service/constants"
 	"github.com/SigNoz/signoz/pkg/query-service/healthcheck"
 	baseint "github.com/SigNoz/signoz/pkg/query-service/interfaces"
-	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
 	baserules "github.com/SigNoz/signoz/pkg/query-service/rules"
 	"github.com/SigNoz/signoz/pkg/query-service/telemetry"
 	"github.com/SigNoz/signoz/pkg/query-service/utils"
 	"go.uber.org/zap"
 )
 
-const AppDbEngine = "sqlite"
-
 type ServerOptions struct {
-	Config            signoz.Config
-	SigNoz            *signoz.SigNoz
-	PromConfigPath    string
-	SkipTopLvlOpsPath string
-	HTTPHostPort      string
-	PrivateHostPort   string
-	// alert specific params
-	DisableRules               bool
-	RuleRepoURL                string
+	Config                     signoz.Config
+	SigNoz                     *signoz.SigNoz
+	HTTPHostPort               string
+	PrivateHostPort            string
 	PreferSpanMetrics          bool
 	CacheConfigPath            string
 	FluxInterval               string
 	FluxIntervalForTraceDetail string
 	Cluster                    string
 	GatewayUrl                 string
-	UseLogsNewSchema           bool
-	UseTraceNewSchema          bool
 	Jwt                        *authtypes.JWT
 }
 
@@ -143,20 +130,10 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 		serverOptions.SigNoz.TelemetryStore,
 		serverOptions.SigNoz.Prometheus,
 		serverOptions.Cluster,
-		serverOptions.UseLogsNewSchema,
-		serverOptions.UseTraceNewSchema,
 		fluxIntervalForTraceDetail,
 		serverOptions.SigNoz.Cache,
 	)
 
-	skipConfig := &basemodel.SkipConfig{}
-	if serverOptions.SkipTopLvlOpsPath != "" {
-		// read skip config
-		skipConfig, err = basemodel.ReadSkipConfig(serverOptions.SkipTopLvlOpsPath)
-		if err != nil {
-			return nil, err
-		}
-	}
 	var c cache.Cache
 	if serverOptions.CacheConfigPath != "" {
 		cacheOpts, err := cache.LoadFromYAMLCacheConfigFile(serverOptions.CacheConfigPath)
@@ -167,13 +144,9 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 	}
 
 	rm, err := makeRulesManager(
-		serverOptions.RuleRepoURL,
 		serverOptions.SigNoz.SQLStore.SQLxDB(),
 		reader,
 		c,
-		serverOptions.DisableRules,
-		serverOptions.UseLogsNewSchema,
-		serverOptions.UseTraceNewSchema,
 		serverOptions.SigNoz.Alertmanager,
 		serverOptions.SigNoz.SQLStore,
 		serverOptions.SigNoz.TelemetryStore,
@@ -241,7 +214,6 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 
 	apiOpts := api.APIHandlerOptions{
 		DataConnector:                 reader,
-		SkipConfig:                    skipConfig,
 		PreferSpanMetrics:             serverOptions.PreferSpanMetrics,
 		AppDao:                        modelDao,
 		RulesManager:                  rm,
@@ -255,8 +227,6 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 		FluxInterval:                  fluxInterval,
 		Gateway:                       gatewayProxy,
 		GatewayUrl:                    serverOptions.GatewayUrl,
-		UseLogsNewSchema:              serverOptions.UseLogsNewSchema,
-		UseTraceNewSchema:             serverOptions.UseTraceNewSchema,
 		JWT:                           serverOptions.Jwt,
 	}
 
@@ -266,8 +236,6 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 	}
 
 	s := &Server{
-		// logger: logger,
-		// tracer: tracer,
 		ruleManager:        rm,
 		serverOptions:      serverOptions,
 		unavailableChannel: make(chan healthcheck.Status),
@@ -334,24 +302,8 @@ func (s *Server) createPrivateServer(apiHandler *api.APIHandler) (*http.Server,
 }
 
 func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*http.Server, error) {
-
 	r := baseapp.NewRouter()
-
-	// add auth middleware
-	getUserFromRequest := func(ctx context.Context) (*types.GettableUser, error) {
-		user, err := auth.GetUserFromReqContext(ctx)
-
-		if err != nil {
-			return nil, err
-		}
-
-		if user.User.OrgID == "" {
-			return nil, basemodel.UnauthorizedError(errors.New("orgId is missing in the claims"))
-		}
-
-		return user, nil
-	}
-	am := baseapp.NewAuthMiddleware(getUserFromRequest)
+	am := middleware.NewAuthZ(s.serverOptions.SigNoz.Instrumentation.Logger())
 
 	r.Use(middleware.NewAuth(zap.L(), s.serverOptions.Jwt, []string{"Authorization", "Sec-WebSocket-Protocol"}).Wrap)
 	r.Use(eemiddleware.NewPat(s.serverOptions.SigNoz.SQLStore, []string{"SIGNOZ-API-KEY"}).Wrap)
@@ -430,13 +382,7 @@ func (s *Server) initListeners() error {
 
 // Start listening on http and private http port concurrently
 func (s *Server) Start(ctx context.Context) error {
-
-	// initiate rule manager first
-	if !s.serverOptions.DisableRules {
-		s.ruleManager.Start(ctx)
-	} else {
-		zap.L().Info("msg: Rules disabled as rules.disable is set to TRUE")
-	}
+	s.ruleManager.Start(ctx)
 
 	err := s.initListeners()
 	if err != nil {
@@ -527,13 +473,9 @@ func (s *Server) Stop() error {
 }
 
 func makeRulesManager(
-	ruleRepoURL string,
 	db *sqlx.DB,
 	ch baseint.Reader,
 	cache cache.Cache,
-	disableRules bool,
-	useLogsNewSchema bool,
-	useTraceNewSchema bool,
 	alertmanager alertmanager.Alertmanager,
 	sqlstore sqlstore.SQLStore,
 	telemetryStore telemetrystore.TelemetryStore,
@@ -543,17 +485,13 @@ func makeRulesManager(
 	managerOpts := &baserules.ManagerOptions{
 		TelemetryStore:      telemetryStore,
 		Prometheus:          prometheus,
-		RepoURL:             ruleRepoURL,
 		DBConn:              db,
 		Context:             context.Background(),
 		Logger:              zap.L(),
-		DisableRules:        disableRules,
 		Reader:              ch,
 		Cache:               cache,
 		EvalDelay:           baseconst.GetEvalDelay(),
 		PrepareTaskFunc:     rules.PrepareTaskFunc,
-		UseLogsNewSchema:    useLogsNewSchema,
-		UseTraceNewSchema:   useTraceNewSchema,
 		PrepareTestRuleFunc: rules.TestNotification,
 		Alertmanager:        alertmanager,
 		SQLStore:            sqlstore,

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

@@ -9,7 +9,6 @@ import (
 	"github.com/SigNoz/signoz/ee/query-service/constants"
 	"github.com/SigNoz/signoz/ee/query-service/model"
 	baseauth "github.com/SigNoz/signoz/pkg/query-service/auth"
-	baseconst "github.com/SigNoz/signoz/pkg/query-service/constants"
 	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
 	"github.com/SigNoz/signoz/pkg/query-service/utils"
 	"github.com/SigNoz/signoz/pkg/types"
@@ -36,12 +35,6 @@ func (m *modelDao) createUserForSAMLRequest(ctx context.Context, email string) (
 		return nil, model.InternalErrorStr("failed to generate password hash")
 	}
 
-	group, apiErr := m.GetGroupByName(ctx, baseconst.ViewerGroup)
-	if apiErr != nil {
-		zap.L().Error("GetGroupByName failed", zap.Error(apiErr))
-		return nil, apiErr
-	}
-
 	user := &types.User{
 		ID:       uuid.New().String(),
 		Name:     "",
@@ -51,11 +44,11 @@ func (m *modelDao) createUserForSAMLRequest(ctx context.Context, email string) (
 			CreatedAt: time.Now(),
 		},
 		ProfilePictureURL: "", // Currently unused
-		GroupID:           group.ID,
+		Role:              authtypes.RoleViewer.String(),
 		OrgID:             domain.OrgID,
 	}
 
-	user, apiErr = m.CreateUser(ctx, user, false)
+	user, apiErr := m.CreateUser(ctx, user, false)
 	if apiErr != nil {
 		zap.L().Error("CreateUser failed", zap.Error(apiErr))
 		return nil, apiErr
@@ -115,7 +108,7 @@ func (m *modelDao) CanUsePassword(ctx context.Context, email string) (bool, base
 			return false, baseapierr
 		}
 
-		if userPayload.Role != baseconst.AdminGroup {
+		if userPayload.Role != authtypes.RoleAdmin.String() {
 			return false, model.BadRequest(fmt.Errorf("auth method not supported"))
 		}
 

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

@@ -9,10 +9,9 @@ import (
 	"net/http"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/SigNoz/signoz/ee/query-service/constants"
 	"github.com/SigNoz/signoz/ee/query-service/model"
+	"github.com/pkg/errors"
 )
 
 var C *Client

ee/query-service/license/manager.go

@@ -239,8 +239,8 @@ func (lm *Manager) ValidateV3(ctx context.Context) (reterr error) {
 func (lm *Manager) ActivateV3(ctx context.Context, licenseKey string) (licenseResponse *model.LicenseV3, errResponse *model.ApiError) {
 	defer func() {
 		if errResponse != nil {
-			claims, ok := authtypes.ClaimsFromContext(ctx)
-			if ok {
+			claims, err := authtypes.ClaimsFromContext(ctx)
+			if err != nil {
 				telemetry.GetInstance().SendEvent(telemetry.TELEMETRY_LICENSE_ACT_FAILED,
 					map[string]interface{}{"err": errResponse.Err.Error()}, claims.Email, true, false)
 			}

ee/query-service/main.go

@@ -11,7 +11,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/config"
 	"github.com/SigNoz/signoz/pkg/config/envprovider"
 	"github.com/SigNoz/signoz/pkg/config/fileprovider"
-	"github.com/SigNoz/signoz/pkg/query-service/auth"
 	baseconst "github.com/SigNoz/signoz/pkg/query-service/constants"
 	"github.com/SigNoz/signoz/pkg/signoz"
 	"github.com/SigNoz/signoz/pkg/sqlstore/sqlstorehook"
@@ -22,6 +21,7 @@ import (
 	"go.uber.org/zap/zapcore"
 )
 
+// Deprecated: Please use the logger from pkg/instrumentation.
 func initZapLog() *zap.Logger {
 	config := zap.NewProductionConfig()
 	config.EncoderConfig.TimeKey = "timestamp"
@@ -51,21 +51,31 @@ func main() {
 	var gatewayUrl string
 	var useLicensesV3 bool
 
+	// Deprecated
 	flag.BoolVar(&useLogsNewSchema, "use-logs-new-schema", false, "use logs_v2 schema for logs")
+	// Deprecated
 	flag.BoolVar(&useTraceNewSchema, "use-trace-new-schema", false, "use new schema for traces")
+	// Deprecated
 	flag.StringVar(&promConfigPath, "config", "./config/prometheus.yml", "(prometheus config to read metrics)")
+	// Deprecated
 	flag.StringVar(&skipTopLvlOpsPath, "skip-top-level-ops", "", "(config file to skip top level operations)")
+	// Deprecated
 	flag.BoolVar(&disableRules, "rules.disable", false, "(disable rule evaluation)")
 	flag.BoolVar(&preferSpanMetrics, "prefer-span-metrics", false, "(prefer span metrics for service level metrics)")
+	// Deprecated
 	flag.IntVar(&maxIdleConns, "max-idle-conns", 50, "(number of connections to maintain in the pool.)")
+	// Deprecated
 	flag.IntVar(&maxOpenConns, "max-open-conns", 100, "(max connections for use at any time.)")
+	// Deprecated
 	flag.DurationVar(&dialTimeout, "dial-timeout", 5*time.Second, "(the maximum time to establish a connection.)")
+	// Deprecated
 	flag.StringVar(&ruleRepoURL, "rules.repo-url", baseconst.AlertHelpPage, "(host address used to build rule link in alert messages)")
 	flag.StringVar(&cacheConfigPath, "experimental.cache-config", "", "(cache config to use)")
 	flag.StringVar(&fluxInterval, "flux-interval", "5m", "(the interval to exclude data from being cached to avoid incorrect cache for data in motion)")
 	flag.StringVar(&fluxIntervalForTraceDetail, "flux-interval-trace-detail", "2m", "(the interval to exclude data from being cached to avoid incorrect cache for trace data in motion)")
 	flag.StringVar(&cluster, "cluster", "cluster", "(cluster name - defaults to 'cluster')")
 	flag.StringVar(&gatewayUrl, "gateway-url", "", "(url to the gateway)")
+	// Deprecated
 	flag.BoolVar(&useLicensesV3, "use-licenses-v3", false, "use licenses_v3 schema for licenses")
 	flag.Parse()
 
@@ -122,19 +132,13 @@ func main() {
 		Config:                     config,
 		SigNoz:                     signoz,
 		HTTPHostPort:               baseconst.HTTPHostPort,
-		PromConfigPath:             promConfigPath,
-		SkipTopLvlOpsPath:          skipTopLvlOpsPath,
 		PreferSpanMetrics:          preferSpanMetrics,
 		PrivateHostPort:            baseconst.PrivateHostPort,
-		DisableRules:               disableRules,
-		RuleRepoURL:                ruleRepoURL,
 		CacheConfigPath:            cacheConfigPath,
 		FluxInterval:               fluxInterval,
 		FluxIntervalForTraceDetail: fluxIntervalForTraceDetail,
 		Cluster:                    cluster,
 		GatewayUrl:                 gatewayUrl,
-		UseLogsNewSchema:           useLogsNewSchema,
-		UseTraceNewSchema:          useTraceNewSchema,
 		Jwt:                        jwt,
 	}
 
@@ -147,10 +151,6 @@ func main() {
 		zap.L().Fatal("Could not start server", zap.Error(err))
 	}
 
-	if err := auth.InitAuthCache(context.Background()); err != nil {
-		zap.L().Fatal("Failed to initialize auth cache", zap.Error(err))
-	}
-
 	signoz.Start(context.Background())
 
 	if err := signoz.Wait(context.Background()); err != nil {

ee/query-service/rules/manager.go

@@ -25,8 +25,6 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 			ruleId,
 			opts.Rule,
 			opts.Reader,
-			opts.UseLogsNewSchema,
-			opts.UseTraceNewSchema,
 			baserules.WithEvalDelay(opts.ManagerOpts.EvalDelay),
 			baserules.WithSQLStore(opts.SQLStore),
 		)
@@ -123,8 +121,6 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, *basemodel.Ap
 			alertname,
 			parsedRule,
 			opts.Reader,
-			opts.UseLogsNewSchema,
-			opts.UseTraceNewSchema,
 			baserules.WithSendAlways(),
 			baserules.WithSendUnmatched(),
 			baserules.WithSQLStore(opts.SQLStore),

ee/query-service/usage/manager.go

@@ -138,15 +138,6 @@ func (lm *Manager) UploadUsage() {
 
 	zap.L().Info("uploading usage data")
 
-	orgName := ""
-	orgNames, orgError := lm.modelDao.GetOrgs(ctx)
-	if orgError != nil {
-		zap.L().Error("failed to get org data: %v", zap.Error(orgError))
-	}
-	if len(orgNames) == 1 {
-		orgName = orgNames[0].Name
-	}
-
 	usagesPayload := []model.Usage{}
 	for _, usage := range usages {
 		usageDataBytes, err := encryption.Decrypt([]byte(usage.ExporterID[:32]), []byte(usage.Data))
@@ -166,7 +157,7 @@ func (lm *Manager) UploadUsage() {
 		usageData.ExporterID = usage.ExporterID
 		usageData.Type = usage.Type
 		usageData.Tenant = "default"
-		usageData.OrgName = orgName
+		usageData.OrgName = "default"
 		usageData.TenantId = lm.tenantID
 		usagesPayload = append(usagesPayload, usageData)
 	}

ee/sqlstore/postgressqlstore/dialect.go

@@ -28,10 +28,9 @@ var (
 	CloudIntegrationReference = `("cloud_integration_id") REFERENCES "cloud_integration" ("id") ON DELETE CASCADE`
 )
 
-type dialect struct {
-}
+type dialect struct{}
 
-func (dialect *dialect) MigrateIntToTimestamp(ctx context.Context, bun bun.IDB, table string, column string) error {
+func (dialect *dialect) IntToTimestamp(ctx context.Context, bun bun.IDB, table string, column string) error {
 	columnType, err := dialect.GetColumnType(ctx, bun, table, column)
 	if err != nil {
 		return err
@@ -78,7 +77,15 @@ func (dialect *dialect) MigrateIntToTimestamp(ctx context.Context, bun bun.IDB,
 	return nil
 }
 
-func (dialect *dialect) MigrateIntToBoolean(ctx context.Context, bun bun.IDB, table string, column string) error {
+func (dialect *dialect) IntToBoolean(ctx context.Context, bun bun.IDB, table string, column string) error {
+	columnExists, err := dialect.ColumnExists(ctx, bun, table, column)
+	if err != nil {
+		return err
+	}
+	if !columnExists {
+		return nil
+	}
+
 	columnType, err := dialect.GetColumnType(ctx, bun, table, column)
 	if err != nil {
 		return err
@@ -151,6 +158,26 @@ func (dialect *dialect) ColumnExists(ctx context.Context, bun bun.IDB, table str
 	return count > 0, nil
 }
 
+func (dialect *dialect) AddColumn(ctx context.Context, bun bun.IDB, table string, column string, columnExpr string) error {
+	exists, err := dialect.ColumnExists(ctx, bun, table, column)
+	if err != nil {
+		return err
+	}
+	if !exists {
+		_, err = bun.
+			NewAddColumn().
+			Table(table).
+			ColumnExpr(column + " " + columnExpr).
+			Exec(ctx)
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return nil
+}
+
 func (dialect *dialect) RenameColumn(ctx context.Context, bun bun.IDB, table string, oldColumnName string, newColumnName string) (bool, error) {
 	oldColumnExists, err := dialect.ColumnExists(ctx, bun, table, oldColumnName)
 	if err != nil {
@@ -162,10 +189,14 @@ func (dialect *dialect) RenameColumn(ctx context.Context, bun bun.IDB, table str
 		return false, err
 	}
 
-	if !oldColumnExists && newColumnExists {
+	if newColumnExists {
 		return true, nil
 	}
 
+	if !oldColumnExists {
+		return false, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "old column: %s doesn't exist", oldColumnName)
+	}
+
 	_, err = bun.
 		ExecContext(ctx, "ALTER TABLE "+table+" RENAME COLUMN "+oldColumnName+" TO "+newColumnName)
 	if err != nil {
@@ -174,6 +205,26 @@ func (dialect *dialect) RenameColumn(ctx context.Context, bun bun.IDB, table str
 	return true, nil
 }
 
+func (dialect *dialect) DropColumn(ctx context.Context, bun bun.IDB, table string, column string) error {
+	exists, err := dialect.ColumnExists(ctx, bun, table, column)
+	if err != nil {
+		return err
+	}
+	if exists {
+		_, err = bun.
+			NewDropColumn().
+			Table(table).
+			Column(column).
+			Exec(ctx)
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return nil
+}
+
 func (dialect *dialect) TableExists(ctx context.Context, bun bun.IDB, table interface{}) (bool, error) {
 
 	count := 0
@@ -368,3 +419,26 @@ func (dialect *dialect) AddPrimaryKey(ctx context.Context, bun bun.IDB, oldModel
 
 	return nil
 }
+
+func (dialect *dialect) DropColumnWithForeignKeyConstraint(ctx context.Context, bunIDB bun.IDB, model interface{}, column string) error {
+	existingTable := bunIDB.Dialect().Tables().Get(reflect.TypeOf(model))
+	columnExists, err := dialect.ColumnExists(ctx, bunIDB, existingTable.Name, column)
+	if err != nil {
+		return err
+	}
+
+	if !columnExists {
+		return nil
+	}
+
+	_, err = bunIDB.
+		NewDropColumn().
+		Model(model).
+		Column(column).
+		Exec(ctx)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

ee/sqlstore/postgressqlstore/provider.go

@@ -4,8 +4,10 @@ import (
 	"context"
 	"database/sql"
 
+	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/jackc/pgx/v5/pgconn"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"github.com/jackc/pgx/v5/stdlib"
 	"github.com/jmoiron/sqlx"
@@ -87,3 +89,20 @@ func (provider *provider) BunDBCtx(ctx context.Context) bun.IDB {
 func (provider *provider) RunInTxCtx(ctx context.Context, opts *sql.TxOptions, cb func(ctx context.Context) error) error {
 	return provider.bundb.RunInTxCtx(ctx, opts, cb)
 }
+
+func (provider *provider) WrapNotFoundErrf(err error, code errors.Code, format string, args ...any) error {
+	if err == sql.ErrNoRows {
+		return errors.Wrapf(err, errors.TypeNotFound, code, format, args...)
+	}
+
+	return err
+}
+
+func (provider *provider) WrapAlreadyExistsErrf(err error, code errors.Code, format string, args ...any) error {
+	var pgErr *pgconn.PgError
+	if errors.As(err, &pgErr) && pgErr.Code == "23505" {
+		return errors.Wrapf(err, errors.TypeAlreadyExists, code, format, args...)
+	}
+
+	return err
+}

frontend/.gitignore

@@ -1,3 +1,4 @@
 
 # Sentry Config File
 .env.sentry-build-plugin
+.qodo

frontend/package.json

@@ -55,7 +55,7 @@
 		"ansi-to-html": "0.7.2",
 		"antd": "5.11.0",
 		"antd-table-saveas-excel": "2.2.1",
-		"axios": "1.7.7",
+		"axios": "1.8.2",
 		"babel-eslint": "^10.1.0",
 		"babel-jest": "^29.6.4",
 		"babel-loader": "9.1.3",

frontend/src/AppRoutes/index.tsx

@@ -64,7 +64,7 @@ function App(): JSX.Element {
 			// wait for the required data to be loaded before doing init for anything!
 			if (!isFetchingActiveLicenseV3 && activeLicenseV3 && org) {
 				const orgName =
-					org && Array.isArray(org) && org.length > 0 ? org[0].name : '';
+					org && Array.isArray(org) && org.length > 0 ? org[0].displayName : '';
 
 				const { name, email, role } = user;
 

frontend/src/AppRoutes/pageComponents.ts

@@ -64,10 +64,6 @@ export const TraceDetail = Loadable(
 		),
 );
 
-export const UsageExplorerPage = Loadable(
-	() => import(/* webpackChunkName: "UsageExplorerPage" */ 'modules/Usage'),
-);
-
 export const SignupPage = Loadable(
 	() => import(/* webpackChunkName: "SignupPage" */ 'pages/SignUp'),
 );

frontend/src/AppRoutes/routes.ts

@@ -57,7 +57,6 @@ import {
 	TracesFunnels,
 	TracesSaveViews,
 	UnAuthorized,
-	UsageExplorerPage,
 	WorkspaceAccessRestricted,
 	WorkspaceBlocked,
 	WorkspaceSuspended,
@@ -155,13 +154,6 @@ const routes: AppRoutes[] = [
 		isPrivate: true,
 		key: 'SETTINGS',
 	},
-	{
-		path: ROUTES.USAGE_EXPLORER,
-		exact: true,
-		component: UsageExplorerPage,
-		isPrivate: true,
-		key: 'USAGE_EXPLORER',
-	},
 	{
 		path: ROUTES.ALL_DASHBOARD,
 		exact: true,

frontend/src/api/logs/GetLogs.ts

@@ -1,26 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
-import { AxiosError } from 'axios';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PayloadProps, Props } from 'types/api/logs/getLogs';
-
-const GetLogs = async (
-	props: Props,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	try {
-		const data = await axios.get(`/logs`, {
-			params: props,
-		});
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: '',
-			payload: data.data.results,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};
-
-export default GetLogs;

frontend/src/api/logs/livetail.ts

@@ -1,19 +0,0 @@
-import apiV1 from 'api/apiV1';
-import getLocalStorageKey from 'api/browser/localstorage/get';
-import { ENVIRONMENT } from 'constants/env';
-import { LOCALSTORAGE } from 'constants/localStorage';
-import { EventSourcePolyfill } from 'event-source-polyfill';
-
-// 10 min in ms
-const TIMEOUT_IN_MS = 10 * 60 * 1000;
-
-export const LiveTail = (queryParams: string): EventSourcePolyfill =>
-	new EventSourcePolyfill(
-		`${ENVIRONMENT.baseURL}${apiV1}logs/tail?${queryParams}`,
-		{
-			headers: {
-				Authorization: `Bearer ${getLocalStorageKey(LOCALSTORAGE.AUTH_TOKEN)}`,
-			},
-			heartbeatTimeout: TIMEOUT_IN_MS,
-		},
-	);

frontend/src/api/user/editOrg.ts

@@ -1,4 +1,4 @@
-import axios from 'api';
+import { ApiV2Instance as axios } from 'api';
 import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
 import { AxiosError } from 'axios';
 import { ErrorResponse, SuccessResponse } from 'types/api';
@@ -8,14 +8,12 @@ const editOrg = async (
 	props: Props,
 ): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
 	try {
-		const response = await axios.put(`/org/${props.orgId}`, {
-			name: props.name,
-			isAnonymous: props.isAnonymous,
-			hasOptedUpdates: props.hasOptedUpdates,
+		const response = await axios.put(`/orgs/me`, {
+			displayName: props.displayName,
 		});
 
 		return {
-			statusCode: 200,
+			statusCode: 204,
 			error: null,
 			message: response.data.status,
 			payload: response.data,

frontend/src/components/NewSelect/CustomMultiSelect.scss

@@ -0,0 +1,13 @@
+.custom-multiselect-dropdown {
+	.divider {
+		height: 1px;
+		background-color: #e8e8e8;
+		margin: 4px 0;
+	}
+
+	.all-option {
+		font-weight: 500;
+		border-bottom: 1px solid #f0f0f0;
+		margin-bottom: 8px;
+	}
+}

frontend/src/components/NewSelect/CustomSelect.tsx

@@ -0,0 +1,606 @@
+/* eslint-disable no-nested-ternary */
+/* eslint-disable sonarjs/cognitive-complexity */
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/function-component-definition */
+import './styles.scss';
+
+import {
+	CloseOutlined,
+	DownOutlined,
+	LoadingOutlined,
+	ReloadOutlined,
+} from '@ant-design/icons';
+import { Color } from '@signozhq/design-tokens';
+import { Select } from 'antd';
+import cx from 'classnames';
+import { SOMETHING_WENT_WRONG } from 'constants/api';
+import { capitalize, isEmpty } from 'lodash-es';
+import { ArrowDown, ArrowUp } from 'lucide-react';
+import type { BaseSelectRef } from 'rc-select';
+import React, {
+	useCallback,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from 'react';
+import { popupContainer } from 'utils/selectPopupContainer';
+
+import { CustomSelectProps, OptionData } from './types';
+import {
+	filterOptionsBySearch,
+	prioritizeOrAddOptionForSingleSelect,
+	SPACEKEY,
+} from './utils';
+
+/**
+ * CustomSelect Component
+ *
+ */
+const CustomSelect: React.FC<CustomSelectProps> = ({
+	placeholder = 'Search...',
+	className,
+	loading = false,
+	onSearch,
+	options = [],
+	value,
+	onChange,
+	defaultActiveFirstOption = true,
+	noDataMessage,
+	onClear,
+	getPopupContainer,
+	dropdownRender,
+	highlightSearch = true,
+	placement = 'bottomLeft',
+	popupMatchSelectWidth = true,
+	popupClassName,
+	errorMessage,
+	allowClear = false,
+	onRetry,
+	...rest
+}) => {
+	// ===== State & Refs =====
+	const [isOpen, setIsOpen] = useState(false);
+	const [searchText, setSearchText] = useState('');
+	const [activeOptionIndex, setActiveOptionIndex] = useState<number>(-1);
+
+	// Refs for element access and scroll behavior
+	const selectRef = useRef<BaseSelectRef>(null);
+	const dropdownRef = useRef<HTMLDivElement>(null);
+	const optionRefs = useRef<Record<number, HTMLDivElement | null>>({});
+
+	// ===== Option Filtering & Processing Utilities =====
+
+	/**
+	 * Checks if a label exists in the provided options
+	 */
+	const isLabelPresent = useCallback(
+		(options: OptionData[], label: string): boolean =>
+			options.some((option) => {
+				const lowerLabel = label.toLowerCase();
+
+				// Check in nested options if they exist
+				if ('options' in option && Array.isArray(option.options)) {
+					return option.options.some(
+						(subOption) => subOption.label.toLowerCase() === lowerLabel,
+					);
+				}
+
+				// Check top-level option
+				return option.label.toLowerCase() === lowerLabel;
+			}),
+		[],
+	);
+
+	/**
+	 * Separates section and non-section options
+	 */
+	const splitOptions = useCallback((options: OptionData[]): {
+		sectionOptions: OptionData[];
+		nonSectionOptions: OptionData[];
+	} => {
+		const sectionOptions: OptionData[] = [];
+		const nonSectionOptions: OptionData[] = [];
+
+		options.forEach((option) => {
+			if ('options' in option && Array.isArray(option.options)) {
+				sectionOptions.push(option);
+			} else {
+				nonSectionOptions.push(option);
+			}
+		});
+
+		return { sectionOptions, nonSectionOptions };
+	}, []);
+
+	/**
+	 * Apply search filtering to options
+	 */
+	const filteredOptions = useMemo(
+		(): OptionData[] => filterOptionsBySearch(options, searchText),
+		[options, searchText],
+	);
+
+	// ===== UI & Rendering Functions =====
+
+	/**
+	 * Highlights matched text in search results
+	 */
+	const highlightMatchedText = useCallback(
+		(text: string, searchQuery: string): React.ReactNode => {
+			if (!searchQuery || !highlightSearch) return text;
+
+			const parts = text.split(new RegExp(`(${searchQuery})`, 'gi'));
+			return (
+				<>
+					{parts.map((part, i) => {
+						// Create a deterministic but unique key
+						const uniqueKey = `${text.substring(0, 3)}-${part.substring(0, 3)}-${i}`;
+
+						return part.toLowerCase() === searchQuery.toLowerCase() ? (
+							<span key={uniqueKey} className="highlight-text">
+								{part}
+							</span>
+						) : (
+							part
+						);
+					})}
+				</>
+			);
+		},
+		[highlightSearch],
+	);
+
+	/**
+	 * Renders an individual option with proper keyboard navigation support
+	 */
+	const renderOptionItem = useCallback(
+		(
+			option: OptionData,
+			isSelected: boolean,
+			index?: number,
+		): React.ReactElement => {
+			const handleSelection = (): void => {
+				if (onChange) {
+					onChange(option.value, option);
+					setIsOpen(false);
+				}
+			};
+
+			const isActive = index === activeOptionIndex;
+			const optionId = `option-${index}`;
+
+			return (
+				<div
+					key={option.value}
+					id={optionId}
+					ref={(el): void => {
+						if (index !== undefined) {
+							optionRefs.current[index] = el;
+						}
+					}}
+					className={cx('option-item', {
+						selected: isSelected,
+						active: isActive,
+					})}
+					onClick={(e): void => {
+						e.stopPropagation();
+						handleSelection();
+					}}
+					onKeyDown={(e): void => {
+						if (e.key === 'Enter' || e.key === SPACEKEY) {
+							e.preventDefault();
+							handleSelection();
+						}
+					}}
+					onMouseEnter={(): void => setActiveOptionIndex(index || -1)}
+					role="option"
+					aria-selected={isSelected}
+					aria-disabled={option.disabled}
+					tabIndex={isActive ? 0 : -1}
+				>
+					<div className="option-content">
+						<div>{highlightMatchedText(String(option.label || ''), searchText)}</div>
+						{option.type === 'custom' && (
+							<div className="option-badge">{capitalize(option.type)}</div>
+						)}
+					</div>
+				</div>
+			);
+		},
+		[highlightMatchedText, searchText, onChange, activeOptionIndex],
+	);
+
+	/**
+	 * Helper function to render option with index tracking
+	 */
+	const renderOptionWithIndex = useCallback(
+		(option: OptionData, isSelected: boolean, idx: number) =>
+			renderOptionItem(option, isSelected, idx),
+		[renderOptionItem],
+	);
+
+	/**
+	 * Custom clear button renderer
+	 */
+	const clearIcon = useCallback(
+		() => (
+			<CloseOutlined
+				onClick={(e): void => {
+					e.stopPropagation();
+					if (onChange) onChange(undefined, []);
+					if (onClear) onClear();
+				}}
+			/>
+		),
+		[onChange, onClear],
+	);
+
+	// ===== Event Handlers =====
+
+	/**
+	 * Handles search input changes
+	 */
+	const handleSearch = useCallback(
+		(value: string): void => {
+			const trimmedValue = value.trim();
+			setSearchText(trimmedValue);
+
+			if (onSearch) onSearch(trimmedValue);
+		},
+		[onSearch],
+	);
+
+	/**
+	 * Prevents event propagation for dropdown clicks
+	 */
+	const handleDropdownClick = useCallback((e: React.MouseEvent): void => {
+		e.stopPropagation();
+	}, []);
+
+	/**
+	 * Comprehensive keyboard navigation handler
+	 */
+	const handleKeyDown = useCallback(
+		(e: React.KeyboardEvent): void => {
+			// Handle keyboard navigation when dropdown is open
+			if (isOpen) {
+				// Get flattened list of all selectable options
+				const getFlatOptions = (): OptionData[] => {
+					if (!filteredOptions) return [];
+
+					const flatList: OptionData[] = [];
+
+					// Process options
+					const { sectionOptions, nonSectionOptions } = splitOptions(
+						isEmpty(value)
+							? filteredOptions
+							: prioritizeOrAddOptionForSingleSelect(filteredOptions, value),
+					);
+
+					// Add custom option if needed
+					if (!isEmpty(searchText) && !isLabelPresent(filteredOptions, searchText)) {
+						flatList.push({
+							label: searchText,
+							value: searchText,
+							type: 'custom',
+						});
+					}
+
+					// Add all options to flat list
+					flatList.push(...nonSectionOptions);
+					sectionOptions.forEach((section) => {
+						if (section.options) {
+							flatList.push(...section.options);
+						}
+					});
+
+					return flatList;
+				};
+
+				const options = getFlatOptions();
+
+				switch (e.key) {
+					case 'ArrowDown':
+						e.preventDefault();
+						setActiveOptionIndex((prev) =>
+							prev < options.length - 1 ? prev + 1 : 0,
+						);
+						break;
+
+					case 'ArrowUp':
+						e.preventDefault();
+						setActiveOptionIndex((prev) =>
+							prev > 0 ? prev - 1 : options.length - 1,
+						);
+						break;
+
+					case 'Tab':
+						// Tab navigation with Shift key support
+						if (e.shiftKey) {
+							e.preventDefault();
+							setActiveOptionIndex((prev) =>
+								prev > 0 ? prev - 1 : options.length - 1,
+							);
+						} else {
+							e.preventDefault();
+							setActiveOptionIndex((prev) =>
+								prev < options.length - 1 ? prev + 1 : 0,
+							);
+						}
+						break;
+
+					case 'Enter':
+						e.preventDefault();
+						if (activeOptionIndex >= 0 && activeOptionIndex < options.length) {
+							// Select the focused option
+							const selectedOption = options[activeOptionIndex];
+							if (onChange) {
+								onChange(selectedOption.value, selectedOption);
+								setIsOpen(false);
+								setActiveOptionIndex(-1);
+							}
+						} else if (!isEmpty(searchText)) {
+							// Add custom value when no option is focused
+							const customOption = {
+								label: searchText,
+								value: searchText,
+								type: 'custom',
+							};
+							if (onChange) {
+								onChange(customOption.value, customOption);
+								setIsOpen(false);
+								setActiveOptionIndex(-1);
+							}
+						}
+						break;
+
+					case 'Escape':
+						e.preventDefault();
+						setIsOpen(false);
+						setActiveOptionIndex(-1);
+						break;
+
+					case ' ': // Space key
+						if (activeOptionIndex >= 0 && activeOptionIndex < options.length) {
+							e.preventDefault();
+							const selectedOption = options[activeOptionIndex];
+							if (onChange) {
+								onChange(selectedOption.value, selectedOption);
+								setIsOpen(false);
+								setActiveOptionIndex(-1);
+							}
+						}
+						break;
+					default:
+						break;
+				}
+			} else if (e.key === 'ArrowDown' || e.key === 'Tab') {
+				// Open dropdown when Down or Tab is pressed while closed
+				e.preventDefault();
+				setIsOpen(true);
+				setActiveOptionIndex(0);
+			}
+		},
+		[
+			isOpen,
+			activeOptionIndex,
+			filteredOptions,
+			searchText,
+			onChange,
+			splitOptions,
+			value,
+			isLabelPresent,
+		],
+	);
+
+	// ===== Dropdown Rendering =====
+
+	/**
+	 * Renders the custom dropdown with sections and keyboard navigation
+	 */
+	const customDropdownRender = useCallback((): React.ReactElement => {
+		// Process options based on current value
+		let processedOptions = isEmpty(value)
+			? filteredOptions
+			: prioritizeOrAddOptionForSingleSelect(filteredOptions, value);
+
+		if (!isEmpty(searchText)) {
+			processedOptions = filterOptionsBySearch(processedOptions, searchText);
+		}
+
+		const { sectionOptions, nonSectionOptions } = splitOptions(processedOptions);
+
+		// Check if we need to add a custom option based on search text
+		const isSearchTextNotPresent =
+			!isEmpty(searchText) && !isLabelPresent(processedOptions, searchText);
+
+		let optionIndex = 0;
+
+		// Add custom option if needed
+		if (isSearchTextNotPresent) {
+			nonSectionOptions.unshift({
+				label: searchText,
+				value: searchText,
+				type: 'custom',
+			});
+		}
+
+		// Helper function to map options with index tracking
+		const mapOptions = (options: OptionData[]): React.ReactNode =>
+			options.map((option) => {
+				const result = renderOptionWithIndex(
+					option,
+					option.value === value,
+					optionIndex,
+				);
+				optionIndex += 1;
+				return result;
+			});
+
+		const customMenu = (
+			<div
+				ref={dropdownRef}
+				className="custom-select-dropdown"
+				onClick={handleDropdownClick}
+				onKeyDown={handleKeyDown}
+				role="listbox"
+				tabIndex={-1}
+				aria-activedescendant={
+					activeOptionIndex >= 0 ? `option-${activeOptionIndex}` : undefined
+				}
+			>
+				{/* Non-section options */}
+				<div className="no-section-options">
+					{nonSectionOptions.length > 0 && mapOptions(nonSectionOptions)}
+				</div>
+
+				{/* Section options */}
+				{sectionOptions.length > 0 &&
+					sectionOptions.map((section) =>
+						!isEmpty(section.options) ? (
+							<div className="select-group" key={section.label}>
+								<div className="group-label" role="heading" aria-level={2}>
+									{section.label}
+								</div>
+								<div role="group" aria-label={`${section.label} options`}>
+									{section.options && mapOptions(section.options)}
+								</div>
+							</div>
+						) : null,
+					)}
+
+				{/* Navigation help footer */}
+				<div className="navigation-footer" role="note">
+					{!loading && !errorMessage && !noDataMessage && (
+						<section className="navigate">
+							<ArrowDown size={8} className="icons" />
+							<ArrowUp size={8} className="icons" />
+							<span className="keyboard-text">to navigate</span>
+						</section>
+					)}
+					{loading && (
+						<div className="navigation-loading">
+							<div className="navigation-icons">
+								<LoadingOutlined />
+							</div>
+							<div className="navigation-text">We are updating the values...</div>
+						</div>
+					)}
+					{errorMessage && !loading && (
+						<div className="navigation-error">
+							<div className="navigation-text">
+								{errorMessage || SOMETHING_WENT_WRONG}
+							</div>
+							<div className="navigation-icons">
+								<ReloadOutlined
+									twoToneColor={Color.BG_CHERRY_400}
+									onClick={(e): void => {
+										e.stopPropagation();
+										if (onRetry) onRetry();
+									}}
+								/>
+							</div>
+						</div>
+					)}
+
+					{noDataMessage && !loading && (
+						<div className="navigation-text">{noDataMessage}</div>
+					)}
+				</div>
+			</div>
+		);
+
+		return dropdownRender ? dropdownRender(customMenu) : customMenu;
+	}, [
+		value,
+		filteredOptions,
+		searchText,
+		splitOptions,
+		isLabelPresent,
+		handleDropdownClick,
+		handleKeyDown,
+		activeOptionIndex,
+		loading,
+		errorMessage,
+		noDataMessage,
+		dropdownRender,
+		renderOptionWithIndex,
+		onRetry,
+	]);
+
+	// ===== Side Effects =====
+
+	// Clear search text when dropdown closes
+	useEffect(() => {
+		if (!isOpen) {
+			setSearchText('');
+			setActiveOptionIndex(-1);
+		}
+	}, [isOpen]);
+
+	// Auto-scroll to active option for keyboard navigation
+	useEffect(() => {
+		if (
+			isOpen &&
+			activeOptionIndex >= 0 &&
+			optionRefs.current[activeOptionIndex]
+		) {
+			optionRefs.current[activeOptionIndex]?.scrollIntoView({
+				behavior: 'smooth',
+				block: 'nearest',
+			});
+		}
+	}, [isOpen, activeOptionIndex]);
+
+	// ===== Final Processing =====
+
+	// Apply highlight to matched text in options
+	const optionsWithHighlight = useMemo(
+		() =>
+			options
+				?.filter((option) =>
+					String(option.label || '')
+						.toLowerCase()
+						.includes(searchText.toLowerCase()),
+				)
+				?.map((option) => ({
+					...option,
+					label: highlightMatchedText(String(option.label || ''), searchText),
+				})),
+		[options, searchText, highlightMatchedText],
+	);
+
+	// ===== Component Rendering =====
+	return (
+		<Select
+			ref={selectRef}
+			className={cx('custom-select', className)}
+			placeholder={placeholder}
+			showSearch
+			filterOption={false}
+			onSearch={handleSearch}
+			value={value}
+			onChange={onChange}
+			onDropdownVisibleChange={setIsOpen}
+			open={isOpen}
+			options={optionsWithHighlight}
+			defaultActiveFirstOption={defaultActiveFirstOption}
+			popupMatchSelectWidth={popupMatchSelectWidth}
+			allowClear={allowClear ? { clearIcon } : false}
+			getPopupContainer={getPopupContainer ?? popupContainer}
+			suffixIcon={<DownOutlined style={{ cursor: 'default' }} />}
+			dropdownRender={customDropdownRender}
+			menuItemSelectedIcon={null}
+			popupClassName={cx('custom-select-dropdown-container', popupClassName)}
+			listHeight={300}
+			placement={placement}
+			optionFilterProp="label"
+			notFoundContent={<div className="empty-message">{noDataMessage}</div>}
+			onKeyDown={handleKeyDown}
+			{...rest}
+		/>
+	);
+};
+
+export default CustomSelect;

frontend/src/components/NewSelect/__test__/CustomMultiSelect.test.tsx

@@ -0,0 +1,263 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+
+import CustomMultiSelect from '../CustomMultiSelect';
+
+// Mock scrollIntoView which isn't available in JSDOM
+window.HTMLElement.prototype.scrollIntoView = jest.fn();
+
+// Mock options data
+const mockOptions = [
+	{ label: 'Option 1', value: 'option1' },
+	{ label: 'Option 2', value: 'option2' },
+	{ label: 'Option 3', value: 'option3' },
+];
+
+const mockGroupedOptions = [
+	{
+		label: 'Group 1',
+		options: [
+			{ label: 'Group 1 - Option 1', value: 'g1-option1' },
+			{ label: 'Group 1 - Option 2', value: 'g1-option2' },
+		],
+	},
+	{
+		label: 'Group 2',
+		options: [
+			{ label: 'Group 2 - Option 1', value: 'g2-option1' },
+			{ label: 'Group 2 - Option 2', value: 'g2-option2' },
+		],
+	},
+];
+
+describe('CustomMultiSelect Component', () => {
+	it('renders with placeholder', () => {
+		const handleChange = jest.fn();
+		render(
+			<CustomMultiSelect
+				placeholder="Select multiple options"
+				options={mockOptions}
+				onChange={handleChange}
+			/>,
+		);
+
+		// Check placeholder exists
+		const placeholderElement = screen.getByText('Select multiple options');
+		expect(placeholderElement).toBeInTheDocument();
+	});
+
+	it('opens dropdown when clicked', async () => {
+		const handleChange = jest.fn();
+		render(<CustomMultiSelect options={mockOptions} onChange={handleChange} />);
+
+		// Click to open the dropdown
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.mouseDown(selectElement);
+
+		// Wait for dropdown to appear
+		await waitFor(() => {
+			expect(screen.getByText('ALL')).toBeInTheDocument(); // The ALL option
+			expect(screen.getByText('Option 1')).toBeInTheDocument();
+			expect(screen.getByText('Option 2')).toBeInTheDocument();
+			expect(screen.getByText('Option 3')).toBeInTheDocument();
+		});
+	});
+
+	it('selects multiple options', async () => {
+		const handleChange = jest.fn();
+
+		// Start with option1 already selected
+		render(
+			<CustomMultiSelect
+				options={mockOptions}
+				onChange={handleChange}
+				value={['option1']}
+			/>,
+		);
+
+		// Open dropdown
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.mouseDown(selectElement);
+
+		// Wait for dropdown to appear
+		await waitFor(() => {
+			expect(screen.getByText('Option 3')).toBeInTheDocument();
+		});
+
+		// Click on Option 3
+		const option3 = screen.getByText('Option 3');
+		fireEvent.click(option3);
+
+		// Verify onChange was called with the right values
+		expect(handleChange).toHaveBeenCalled();
+	});
+
+	it('selects ALL options when ALL is clicked', async () => {
+		const handleChange = jest.fn();
+		render(
+			<CustomMultiSelect
+				options={mockOptions}
+				onChange={handleChange}
+				enableAllSelection
+			/>,
+		);
+
+		// Open dropdown
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.mouseDown(selectElement);
+
+		// Wait for dropdown to appear
+		await waitFor(() => {
+			expect(screen.getByText('ALL')).toBeInTheDocument();
+		});
+
+		// Click on ALL option
+		const allOption = screen.getByText('ALL');
+		fireEvent.click(allOption);
+
+		// Verify onChange was called with all option values
+		expect(handleChange).toHaveBeenCalledWith(
+			['option1', 'option2', 'option3'],
+			expect.arrayContaining([
+				expect.objectContaining({ value: 'option1' }),
+				expect.objectContaining({ value: 'option2' }),
+				expect.objectContaining({ value: 'option3' }),
+			]),
+		);
+	});
+
+	it('displays selected options as tags', async () => {
+		render(
+			<CustomMultiSelect options={mockOptions} value={['option1', 'option2']} />,
+		);
+
+		// Check that option values are shown as tags (not labels)
+		expect(screen.getByText('option1')).toBeInTheDocument();
+		expect(screen.getByText('option2')).toBeInTheDocument();
+	});
+
+	it('removes a tag when clicked', async () => {
+		const handleChange = jest.fn();
+		render(
+			<CustomMultiSelect
+				options={mockOptions}
+				value={['option1', 'option2']}
+				onChange={handleChange}
+			/>,
+		);
+
+		// Find close button on Option 1 tag and click it
+		const closeButtons = document.querySelectorAll(
+			'.ant-select-selection-item-remove',
+		);
+		fireEvent.click(closeButtons[0]);
+
+		// Verify onChange was called with remaining option
+		expect(handleChange).toHaveBeenCalledWith(
+			['option2'],
+			expect.arrayContaining([expect.objectContaining({ value: 'option2' })]),
+		);
+	});
+
+	it('filters options when searching', async () => {
+		render(<CustomMultiSelect options={mockOptions} />);
+
+		// Open dropdown
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.mouseDown(selectElement);
+
+		// Type into search box - get input directly
+		const inputElement = selectElement.querySelector('input');
+		if (inputElement) {
+			fireEvent.change(inputElement, { target: { value: '2' } });
+		}
+
+		// Wait for the dropdown filtering to happen
+		await waitFor(() => {
+			// Check that the dropdown is present
+			const dropdownElement = document.querySelector(
+				'.custom-multiselect-dropdown',
+			);
+			expect(dropdownElement).toBeInTheDocument();
+
+			// Verify Option 2 is visible in the dropdown
+			const options = document.querySelectorAll('.option-label-text');
+			let foundOption2 = false;
+
+			options.forEach((option) => {
+				const text = option.textContent || '';
+				if (text.includes('Option 2')) foundOption2 = true;
+			});
+
+			expect(foundOption2).toBe(true);
+		});
+	});
+
+	it('renders grouped options correctly', async () => {
+		render(<CustomMultiSelect options={mockGroupedOptions} />);
+
+		// Open dropdown
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.mouseDown(selectElement);
+
+		// Check group headers and options
+		await waitFor(() => {
+			expect(screen.getByText('Group 1')).toBeInTheDocument();
+			expect(screen.getByText('Group 2')).toBeInTheDocument();
+			expect(screen.getByText('Group 1 - Option 1')).toBeInTheDocument();
+			expect(screen.getByText('Group 1 - Option 2')).toBeInTheDocument();
+			expect(screen.getByText('Group 2 - Option 1')).toBeInTheDocument();
+			expect(screen.getByText('Group 2 - Option 2')).toBeInTheDocument();
+		});
+	});
+
+	it('shows loading state', () => {
+		render(<CustomMultiSelect options={mockOptions} loading />);
+
+		// Open dropdown
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.mouseDown(selectElement);
+
+		// Check loading text is displayed
+		expect(screen.getByText('We are updating the values...')).toBeInTheDocument();
+	});
+
+	it('shows error message', () => {
+		render(
+			<CustomMultiSelect
+				options={mockOptions}
+				errorMessage="Test error message"
+			/>,
+		);
+
+		// Open dropdown
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.mouseDown(selectElement);
+
+		// Check error message is displayed
+		expect(screen.getByText('Test error message')).toBeInTheDocument();
+	});
+
+	it('shows no data message', () => {
+		render(<CustomMultiSelect options={[]} noDataMessage="No data available" />);
+
+		// Open dropdown
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.mouseDown(selectElement);
+
+		// Check no data message is displayed
+		expect(screen.getByText('No data available')).toBeInTheDocument();
+	});
+
+	it('shows "ALL" tag when all options are selected', () => {
+		render(
+			<CustomMultiSelect
+				options={mockOptions}
+				value={['option1', 'option2', 'option3']}
+				maxTagCount={2}
+			/>,
+		);
+
+		// When all options are selected, component shows ALL tag instead
+		expect(screen.getByText('ALL')).toBeInTheDocument();
+	});
+});

frontend/src/components/NewSelect/__test__/CustomSelect.test.tsx

@@ -0,0 +1,206 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+
+import CustomSelect from '../CustomSelect';
+
+// Mock scrollIntoView which isn't available in JSDOM
+window.HTMLElement.prototype.scrollIntoView = jest.fn();
+
+// Mock options data
+const mockOptions = [
+	{ label: 'Option 1', value: 'option1' },
+	{ label: 'Option 2', value: 'option2' },
+	{ label: 'Option 3', value: 'option3' },
+];
+
+const mockGroupedOptions = [
+	{
+		label: 'Group 1',
+		options: [
+			{ label: 'Group 1 - Option 1', value: 'g1-option1' },
+			{ label: 'Group 1 - Option 2', value: 'g1-option2' },
+		],
+	},
+	{
+		label: 'Group 2',
+		options: [
+			{ label: 'Group 2 - Option 1', value: 'g2-option1' },
+			{ label: 'Group 2 - Option 2', value: 'g2-option2' },
+		],
+	},
+];
+
+describe('CustomSelect Component', () => {
+	it('renders with placeholder and options', () => {
+		const handleChange = jest.fn();
+		render(
+			<CustomSelect
+				placeholder="Test placeholder"
+				options={mockOptions}
+				onChange={handleChange}
+			/>,
+		);
+
+		// Check placeholder exists in the DOM (not using getByPlaceholderText)
+		const placeholderElement = screen.getByText('Test placeholder');
+		expect(placeholderElement).toBeInTheDocument();
+	});
+
+	it('opens dropdown when clicked', async () => {
+		const handleChange = jest.fn();
+		render(<CustomSelect options={mockOptions} onChange={handleChange} />);
+
+		// Click to open the dropdown
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.mouseDown(selectElement);
+
+		// Wait for dropdown to appear
+		await waitFor(() => {
+			expect(screen.getByText('Option 1')).toBeInTheDocument();
+			expect(screen.getByText('Option 2')).toBeInTheDocument();
+			expect(screen.getByText('Option 3')).toBeInTheDocument();
+		});
+	});
+
+	it('calls onChange when option is selected', async () => {
+		const handleChange = jest.fn();
+		render(<CustomSelect options={mockOptions} onChange={handleChange} />);
+
+		// Open dropdown
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.mouseDown(selectElement);
+
+		// Click on an option
+		await waitFor(() => {
+			const option = screen.getByText('Option 2');
+			fireEvent.click(option);
+		});
+
+		// Check onChange was called with correct value
+		expect(handleChange).toHaveBeenCalledWith('option2', expect.anything());
+	});
+
+	it('filters options when searching', async () => {
+		render(<CustomSelect options={mockOptions} />);
+
+		// Open dropdown
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.mouseDown(selectElement);
+
+		// Type into search box
+		fireEvent.change(selectElement, { target: { value: '2' } });
+
+		// Dropdown should only show Option 2
+		await waitFor(() => {
+			// Check that the dropdown is present
+			const dropdownElement = document.querySelector('.custom-select-dropdown');
+			expect(dropdownElement).toBeInTheDocument();
+
+			// Use a simple approach to verify filtering
+			const allOptionsInDropdown = document.querySelectorAll('.option-item');
+			let foundOption2 = false;
+
+			allOptionsInDropdown.forEach((option) => {
+				if (option.textContent?.includes('Option 2')) {
+					foundOption2 = true;
+				}
+
+				// Should not show Options 1 or 3
+				expect(option.textContent).not.toContain('Option 1');
+				expect(option.textContent).not.toContain('Option 3');
+			});
+
+			expect(foundOption2).toBe(true);
+		});
+	});
+
+	it('renders grouped options correctly', async () => {
+		const handleChange = jest.fn();
+		render(<CustomSelect options={mockGroupedOptions} onChange={handleChange} />);
+
+		// Open dropdown
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.mouseDown(selectElement);
+
+		// Check group headers and options
+		await waitFor(() => {
+			expect(screen.getByText('Group 1')).toBeInTheDocument();
+			expect(screen.getByText('Group 2')).toBeInTheDocument();
+			expect(screen.getByText('Group 1 - Option 1')).toBeInTheDocument();
+			expect(screen.getByText('Group 1 - Option 2')).toBeInTheDocument();
+			expect(screen.getByText('Group 2 - Option 1')).toBeInTheDocument();
+			expect(screen.getByText('Group 2 - Option 2')).toBeInTheDocument();
+		});
+	});
+
+	it('shows loading state', () => {
+		render(<CustomSelect options={mockOptions} loading />);
+
+		// Open dropdown
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.mouseDown(selectElement);
+
+		// Check loading text is displayed
+		expect(screen.getByText('We are updating the values...')).toBeInTheDocument();
+	});
+
+	it('shows error message', () => {
+		render(
+			<CustomSelect options={mockOptions} errorMessage="Test error message" />,
+		);
+
+		// Open dropdown
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.mouseDown(selectElement);
+
+		// Check error message is displayed
+		expect(screen.getByText('Test error message')).toBeInTheDocument();
+	});
+
+	it('shows no data message', () => {
+		render(<CustomSelect options={[]} noDataMessage="No data available" />);
+
+		// Open dropdown
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.mouseDown(selectElement);
+
+		// Check no data message is displayed
+		expect(screen.getByText('No data available')).toBeInTheDocument();
+	});
+
+	it('supports keyboard navigation', async () => {
+		const handleChange = jest.fn();
+		render(<CustomSelect options={mockOptions} onChange={handleChange} />);
+
+		// Open dropdown using keyboard
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.focus(selectElement);
+
+		// Press down arrow to open dropdown
+		fireEvent.keyDown(selectElement, { key: 'ArrowDown' });
+
+		// Wait for dropdown to appear
+		await waitFor(() => {
+			expect(screen.getByText('Option 1')).toBeInTheDocument();
+		});
+	});
+
+	it('handles selection via keyboard', async () => {
+		const handleChange = jest.fn();
+		render(<CustomSelect options={mockOptions} onChange={handleChange} />);
+
+		// Open dropdown
+		const selectElement = screen.getByRole('combobox');
+		fireEvent.mouseDown(selectElement);
+
+		// Wait for dropdown to appear then press Enter
+		await waitFor(() => {
+			expect(screen.getByText('Option 1')).toBeInTheDocument();
+
+			// Press Enter to select first option
+			fireEvent.keyDown(screen.getByText('Option 1'), { key: 'Enter' });
+		});
+
+		// Check onChange was called
+		expect(handleChange).toHaveBeenCalled();
+	});
+});

frontend/src/components/NewSelect/index.ts

@@ -0,0 +1,4 @@
+import CustomMultiSelect from './CustomMultiSelect';
+import CustomSelect from './CustomSelect';
+
+export { CustomMultiSelect, CustomSelect };

frontend/src/components/NewSelect/styles.scss

@@ -0,0 +1,838 @@
+// Main container styles
+
+// make const of #2c3044
+$custom-border-color: #2c3044;
+
+.custom-select {
+	width: 100%;
+	position: relative;
+
+	&.ant-select-focused {
+		.ant-select-selector {
+			border-color: var(--bg-robin-500);
+			box-shadow: 0 0 0 2px rgba(78, 116, 248, 0.2);
+		}
+	}
+
+	.ant-select-selection-placeholder {
+		color: rgba(192, 193, 195, 0.45);
+	}
+
+	// Base styles are for dark mode
+	.ant-select-selector {
+		background-color: var(--bg-ink-400);
+		border-color: var(--bg-slate-400);
+	}
+
+	.ant-select-clear {
+		background-color: var(--bg-ink-400);
+		color: rgba(192, 193, 195, 0.7);
+	}
+}
+
+// Keep chip styles ONLY in the multi-select
+.custom-multiselect {
+	width: 100%;
+	position: relative;
+
+	.ant-select-selector {
+		max-height: 200px;
+		overflow: auto;
+		scrollbar-width: thin;
+		background-color: var(--bg-ink-400);
+		border-color: var(--bg-slate-400);
+
+		&::-webkit-scrollbar {
+			width: 6px;
+		}
+
+		&::-webkit-scrollbar-thumb {
+			background-color: $custom-border-color;
+			border-radius: 3px;
+		}
+
+		&::-webkit-scrollbar-track {
+			background-color: var(--bg-slate-400);
+		}
+	}
+
+	&.ant-select-focused {
+		.ant-select-selector {
+			border-color: var(--bg-robin-500);
+			box-shadow: 0 0 0 2px rgba(78, 116, 248, 0.2);
+		}
+	}
+
+	.ant-select-selection-placeholder {
+		color: rgba(192, 193, 195, 0.45);
+	}
+
+	// Customize tags in multiselect (dark mode by default)
+	.ant-select-selection-item {
+		background-color: var(--bg-slate-400);
+		border-radius: 4px;
+		border: 1px solid $custom-border-color;
+		margin-right: 4px;
+		transition: all 0.2s;
+		color: var(--bg-vanilla-400);
+
+		// Style for active tag (keyboard navigation)
+		&-active {
+			border-color: var(--bg-robin-500) !important;
+			background-color: rgba(78, 116, 248, 0.15) !important;
+			outline: 2px solid rgba(78, 116, 248, 0.2);
+		}
+
+		// Style for selected tags (via keyboard or mouse selection)
+		&-selected {
+			border-color: var(--bg-robin-500) !important;
+			background-color: rgba(78, 116, 248, 0.15) !important;
+			box-shadow: 0 0 0 2px rgba(78, 116, 248, 0.2);
+		}
+
+		.ant-select-selection-item-content {
+			color: var(--bg-vanilla-400);
+		}
+
+		.ant-select-selection-item-remove {
+			color: rgba(192, 193, 195, 0.7);
+			&:hover {
+				color: rgba(192, 193, 195, 1);
+			}
+		}
+	}
+
+	// Class applied when in selection mode
+	&.has-selection {
+		.ant-select-selection-item-selected {
+			cursor: move; // Indicate draggable
+		}
+
+		// Change cursor for selection
+		.ant-select-selector {
+			cursor: text;
+		}
+	}
+}
+
+// Dropdown styles
+.custom-select-dropdown-container,
+.custom-multiselect-dropdown-container {
+	z-index: 1050 !important;
+	padding: 0;
+	box-shadow: 0 3px 6px -4px rgba(0, 0, 0, 0.5), 0 6px 16px 0 rgba(0, 0, 0, 0.4),
+		0 9px 28px 8px rgba(0, 0, 0, 0.3);
+	background-color: var(--bg-ink-400);
+	border: 1px solid var(--bg-slate-400);
+
+	.ant-select-item {
+		padding: 8px 12px;
+		color: var(--bg-vanilla-400);
+
+		// Make keyboard navigation visible
+		&-option-active {
+			background-color: var(--bg-slate-400) !important;
+		}
+
+		&-option-selected {
+			background-color: rgba(78, 116, 248, 0.15) !important;
+		}
+	}
+}
+
+.custom-select-dropdown-container,
+.custom-multiselect-dropdown-container {
+	width: 100%;
+	overflow-x: auto;
+	overflow-y: hidden;
+	resize: horizontal;
+	min-width: 300px !important;
+
+	.empty-message {
+		padding: 12px;
+		text-align: center;
+		color: rgba(192, 193, 195, 0.45);
+	}
+}
+
+// Custom dropdown styles for single select
+.custom-select-dropdown {
+	padding: 8px 0 0 0;
+	max-height: 500px;
+	overflow-y: auto;
+	overflow-x: hidden;
+	scrollbar-width: thin;
+	border-radius: 4px;
+	border: 1px solid var(--bg-slate-400);
+	width: 100%;
+	background-color: var(--bg-ink-400);
+
+	&::-webkit-scrollbar {
+		width: 6px;
+	}
+
+	&::-webkit-scrollbar-thumb {
+		background-color: $custom-border-color;
+		border-radius: 3px;
+	}
+
+	&::-webkit-scrollbar-track {
+		background-color: var(--bg-slate-400);
+	}
+
+	.no-section-options {
+		margin-bottom: 8px;
+	}
+
+	.select-group {
+		margin-bottom: 16px;
+		border-radius: 4px;
+		overflow: hidden;
+
+		.group-label {
+			font-weight: 500;
+			padding: 4px 12px;
+			font-size: 13px;
+			color: var(--bg-vanilla-400);
+			background-color: var(--bg-slate-400);
+			border-bottom: 1px solid $custom-border-color;
+			border-top: 1px solid $custom-border-color;
+			position: relative;
+			z-index: 1;
+			margin-bottom: 4px;
+		}
+	}
+
+	.option-item {
+		padding: 8px 12px;
+		cursor: pointer;
+		display: flex;
+		align-items: center;
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		color: var(--bg-vanilla-400);
+
+		&:hover {
+			background-color: var(--bg-slate-400);
+		}
+
+		&.selected {
+			background-color: rgba(78, 116, 248, 0.15);
+			font-weight: 500;
+		}
+
+		&.active {
+			background-color: rgba(78, 116, 248, 0.15);
+			border-color: var(--bg-robin-500);
+		}
+
+		.option-content {
+			display: flex;
+			justify-content: space-between;
+			align-items: center;
+			width: 100%;
+
+			.option-label-text {
+				margin-bottom: 0;
+			}
+
+			.option-badge {
+				font-size: 12px;
+				padding: 2px 6px;
+				border-radius: 4px;
+				background-color: $custom-border-color;
+				color: var(--bg-vanilla-400);
+				margin-left: 8px;
+			}
+		}
+	}
+
+	.loading-container {
+		display: flex;
+		justify-content: center;
+		padding: 12px;
+	}
+}
+
+.navigation-footer {
+	display: flex;
+	align-items: center;
+	padding: 8px 12px;
+	border-top: 1px solid var(--bg-slate-400);
+	position: sticky;
+	bottom: 0;
+	background-color: var(--bg-ink-400);
+	z-index: 1;
+
+	.navigation-icons {
+		display: flex;
+		margin-right: 8px;
+		color: var(--bg-vanilla-400);
+	}
+
+	.navigation-text {
+		color: var(--bg-vanilla-400);
+		font-size: 12px;
+	}
+
+	.navigation-error {
+		.navigation-text,
+		.navigation-icons {
+			color: var(--bg-cherry-500) !important;
+		}
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		width: 100%;
+		gap: 4px;
+	}
+
+	.navigation-loading {
+		display: flex;
+		align-items: center;
+		gap: 8px;
+
+		.navigation-text,
+		.navigation-icons {
+			color: var(--bg-robin-600) !important;
+		}
+	}
+
+	.navigate {
+		display: flex;
+		align-items: center;
+		padding-right: 12px;
+		gap: 6px;
+
+		.icons {
+			width: 14px;
+			height: 14px;
+			flex-shrink: 0;
+			border-radius: 2.286px;
+			border-top: 1.143px solid var(--bg-ink-200);
+			border-right: 1.143px solid var(--bg-ink-200);
+			border-bottom: 2.286px solid var(--bg-ink-200);
+			border-left: 1.143px solid var(--bg-ink-200);
+			background: var(--Ink-400, var(--bg-ink-400));
+		}
+	}
+}
+
+// Custom dropdown styles for multi-select
+.custom-multiselect-dropdown {
+	padding: 8px 0 0 0;
+	max-height: 500px;
+	overflow-y: auto;
+	overflow-x: hidden;
+	scrollbar-width: thin;
+	border-radius: 4px;
+	border: 1px solid var(--bg-slate-400);
+	width: 100%;
+	background-color: var(--bg-ink-400);
+
+	.select-all-option,
+	.custom-value-option {
+		padding: 8px 12px;
+		border-bottom: 1px solid $custom-border-color;
+		margin-bottom: 8px;
+		background-color: var(--bg-slate-400);
+		position: sticky;
+		top: 0;
+		z-index: 1;
+	}
+
+	.selected-values-section {
+		padding: 0 0 8px 0;
+		border-bottom: 1px solid $custom-border-color;
+		margin-bottom: 8px;
+
+		.selected-option {
+			padding: 4px 12px;
+		}
+	}
+
+	.select-group {
+		margin-bottom: 12px;
+		overflow: hidden;
+
+		.group-label {
+			font-weight: 500;
+			padding: 4px 12px;
+			font-size: 13px;
+			color: var(--bg-vanilla-400);
+			background-color: var(--bg-slate-400);
+			border-bottom: 1px solid $custom-border-color;
+			border-top: 1px solid $custom-border-color;
+			position: relative;
+			z-index: 1;
+		}
+	}
+
+	.option-item {
+		padding: 8px 12px;
+		cursor: pointer;
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		color: var(--bg-vanilla-400);
+
+		&.active {
+			background-color: rgba(78, 116, 248, 0.15);
+			border-color: var(--bg-robin-500);
+		}
+
+		&:hover {
+			background-color: var(--bg-slate-400);
+		}
+
+		&.selected {
+			background-color: rgba(78, 116, 248, 0.15);
+			font-weight: 500;
+		}
+
+		&.all-option {
+			font-weight: 500;
+			border-bottom: 1px solid $custom-border-color;
+			margin-bottom: 8px;
+		}
+
+		.option-checkbox {
+			width: 100%;
+
+			> span:not(.ant-checkbox) {
+				width: 100%;
+			}
+
+			.option-content {
+				display: flex;
+				justify-content: space-between;
+				align-items: center;
+				width: 100%;
+
+				.option-label-text {
+					margin-bottom: 0;
+				}
+
+				.option-badge {
+					font-size: 12px;
+					padding: 2px 6px;
+					border-radius: 4px;
+					background-color: $custom-border-color;
+					color: var(--bg-vanilla-400);
+					margin-left: 8px;
+				}
+			}
+
+			.only-btn {
+				display: none;
+			}
+			.toggle-btn {
+				display: none;
+			}
+
+			.only-btn:hover {
+				background-color: unset;
+			}
+			.toggle-btn:hover {
+				background-color: unset;
+			}
+
+			.option-content:hover {
+				.only-btn {
+					display: flex;
+					align-items: center;
+					justify-content: center;
+					height: 21px;
+				}
+				.toggle-btn {
+					display: none;
+				}
+
+				.option-badge {
+					display: none;
+				}
+			}
+		}
+
+		.option-checkbox:hover {
+			.toggle-btn {
+				display: flex;
+				align-items: center;
+				justify-content: center;
+				height: 21px;
+			}
+			.option-badge {
+				display: none;
+			}
+		}
+	}
+
+	.loading-container {
+		display: flex;
+		justify-content: center;
+		padding: 12px;
+	}
+
+	.empty-message {
+		padding: 12px;
+		text-align: center;
+		color: rgba(192, 193, 195, 0.45);
+	}
+
+	.status-message {
+		padding: 8px 12px;
+		text-align: center;
+		font-style: italic;
+		color: rgba(192, 193, 195, 0.65);
+		border-top: 1px dashed $custom-border-color;
+	}
+}
+
+// Custom styles for highlight text
+.highlight-text {
+	background-color: rgba(78, 116, 248, 0.2);
+	padding: 0 1px;
+	border-radius: 2px;
+	font-weight: 500;
+}
+
+// Custom option styles for keyboard navigation
+.custom-option {
+	&.focused,
+	&.ant-select-item-option-active {
+		background-color: var(--bg-slate-400) !important;
+	}
+}
+
+// Improve the sticky headers appearance
+.custom-select-dropdown-container {
+	.group-label,
+	.ant-select-item-group {
+		position: sticky;
+		top: 0;
+		z-index: 2;
+		background-color: var(--bg-slate-400);
+		border-bottom: 1px solid $custom-border-color;
+		padding: 4px 12px;
+		margin: 0;
+		width: 100%; // Ensure the header spans full width
+		box-shadow: 0 1px 2px rgba(0, 0, 0, 0.2); // Add subtle shadow for separation
+	}
+
+	// Ensure proper spacing between sections
+	.select-group {
+		margin-bottom: 8px;
+		position: relative; // Create a positioning context
+	}
+}
+
+// Custom scrollbar styling (shared between components)
+@mixin custom-scrollbar {
+	scrollbar-width: thin;
+	scrollbar-color: rgba(192, 193, 195, 0.3) rgba(29, 33, 45, 0.6);
+
+	&::-webkit-scrollbar {
+		width: 6px;
+		height: 6px;
+	}
+
+	&::-webkit-scrollbar-track {
+		background-color: rgba(29, 33, 45, 0.6);
+		border-radius: 10px;
+	}
+
+	&::-webkit-scrollbar-thumb {
+		background-color: rgba(192, 193, 195, 0.3);
+		border-radius: 10px;
+		transition: background-color 0.2s ease;
+
+		&:hover {
+			background-color: rgba(192, 193, 195, 0.5);
+		}
+	}
+}
+
+// Subtle nested scrollbar styling
+@mixin nested-scrollbar {
+	scrollbar-width: thin;
+	scrollbar-color: rgba(192, 193, 195, 0.2) rgba(29, 33, 45, 0.6);
+
+	&::-webkit-scrollbar {
+		width: 4px;
+		height: 4px;
+	}
+
+	&::-webkit-scrollbar-track {
+		background-color: rgba(29, 33, 45, 0.6);
+		border-radius: 10px;
+	}
+
+	&::-webkit-scrollbar-thumb {
+		background-color: rgba(192, 193, 195, 0.2);
+		border-radius: 10px;
+
+		&:hover {
+			background-color: rgba(192, 193, 195, 0.3);
+		}
+	}
+}
+
+// Apply to main dropdown containers
+.custom-select-dropdown,
+.custom-multiselect-dropdown {
+	@include custom-scrollbar;
+
+	// Main content area
+	.options-container {
+		@include custom-scrollbar;
+		padding-right: 2px; // Add slight padding to prevent content touching scrollbar
+	}
+
+	// Non-sectioned options
+	.no-section-options {
+		@include nested-scrollbar;
+		margin-right: 2px;
+		padding-right: 2px;
+	}
+}
+
+// Apply to dropdown container wrappers
+.custom-select-dropdown-container,
+.custom-multiselect-dropdown-container {
+	@include custom-scrollbar;
+
+	// Add subtle shadow inside to indicate scrollable area
+	&.has-overflow {
+		box-shadow: inset 0 -10px 10px -10px rgba(0, 0, 0, 0.2);
+	}
+}
+
+// Light Mode Overrides
+.lightMode {
+	.custom-select {
+		.ant-select-selector {
+			background-color: var(--bg-vanilla-100);
+			border-color: #e9e9e9;
+		}
+
+		.ant-select-selection-placeholder {
+			color: rgba(0, 0, 0, 0.45);
+		}
+
+		.ant-select-clear {
+			background-color: var(--bg-vanilla-100);
+			color: rgba(0, 0, 0, 0.45);
+		}
+
+		&.ant-select-focused {
+			.ant-select-selector {
+				border-color: #1890ff;
+				box-shadow: 0 0 0 2px rgba(24, 144, 255, 0.2);
+			}
+		}
+	}
+
+	.custom-multiselect {
+		.ant-select-selector {
+			background-color: var(--bg-vanilla-100);
+			border-color: #e9e9e9;
+
+			&::-webkit-scrollbar-thumb {
+				background-color: #ccc;
+			}
+
+			&::-webkit-scrollbar-track {
+				background-color: #f0f0f0;
+			}
+		}
+
+		.ant-select-selection-placeholder {
+			color: rgba(0, 0, 0, 0.45);
+		}
+
+		.ant-select-selection-item {
+			background-color: #f5f5f5;
+			border: 1px solid #e8e8e8;
+			color: rgba(0, 0, 0, 0.85);
+
+			.ant-select-selection-item-content {
+				color: rgba(0, 0, 0, 0.85);
+			}
+
+			.ant-select-selection-item-remove {
+				color: rgba(0, 0, 0, 0.45);
+				&:hover {
+					color: rgba(0, 0, 0, 0.85);
+				}
+			}
+
+			&-active {
+				border-color: var(--bg-robin-500) !important;
+				background-color: var(--bg-vanilla-300) !important;
+			}
+
+			&-selected {
+				border-color: #1890ff !important;
+				background-color: var(--bg-vanilla-300) !important;
+			}
+		}
+	}
+
+	.custom-select-dropdown-container,
+	.custom-multiselect-dropdown-container {
+		background-color: var(--bg-vanilla-100);
+		border: 1px solid #f0f0f0;
+		box-shadow: 0 3px 6px -4px rgba(0, 0, 0, 0.12),
+			0 6px 16px 0 rgba(0, 0, 0, 0.08), 0 9px 28px 8px rgba(0, 0, 0, 0.05);
+
+		.empty-message {
+			color: rgba(0, 0, 0, 0.45);
+		}
+
+		.ant-select-item {
+			color: rgba(0, 0, 0, 0.85);
+
+			&-option-active {
+				background-color: #f5f5f5 !important;
+			}
+
+			&-option-selected {
+				background-color: var(--bg-vanilla-300) !important;
+			}
+		}
+	}
+
+	.custom-select-dropdown,
+	.custom-multiselect-dropdown {
+		border: 1px solid #f0f0f0;
+		background-color: var(--bg-vanilla-100);
+
+		&::-webkit-scrollbar-thumb {
+			background-color: #ccc;
+		}
+
+		&::-webkit-scrollbar-track {
+			background-color: #f0f0f0;
+		}
+
+		.select-group {
+			.group-label {
+				color: rgba(0, 0, 0, 0.85);
+				background-color: #fafafa;
+				border-bottom: 1px solid #f0f0f0;
+				border-top: 1px solid #f0f0f0;
+			}
+		}
+
+		.option-item {
+			color: rgba(0, 0, 0, 0.85);
+
+			&:hover {
+				background-color: #f5f5f5;
+			}
+
+			&.selected {
+				background-color: var(--bg-vanilla-300);
+			}
+
+			&.active {
+				background-color: var(--bg-vanilla-300);
+				border-color: #91d5ff;
+			}
+
+			.option-content {
+				.option-badge {
+					background-color: #f0f0f0;
+					color: #666;
+				}
+			}
+		}
+	}
+
+	.navigation-footer {
+		border-top: 1px solid #f0f0f0;
+		background-color: var(--bg-vanilla-100);
+
+		.navigation-icons {
+			color: rgba(0, 0, 0, 0.45);
+		}
+
+		.navigation-text {
+			color: rgba(0, 0, 0, 0.45);
+		}
+
+		.navigate {
+			.icons {
+				border-top: 1.143px solid var(--bg-ink-200);
+				border-right: 1.143px solid var(--bg-ink-200);
+				border-bottom: 2.286px solid var(--bg-ink-200);
+				border-left: 1.143px solid var(--bg-ink-200);
+				background: var(--bg-vanilla-300);
+			}
+		}
+	}
+
+	.custom-multiselect-dropdown {
+		.select-all-option,
+		.custom-value-option {
+			border-bottom: 1px solid #f0f0f0;
+			background-color: #fafafa;
+		}
+
+		.selected-values-section {
+			border-bottom: 1px solid #f0f0f0;
+		}
+
+		.status-message {
+			color: rgba(0, 0, 0, 0.65);
+			border-top: 1px dashed #f0f0f0;
+		}
+
+		.option-item {
+			&.all-option {
+				border-bottom: 1px solid #f0f0f0;
+			}
+		}
+	}
+
+	.highlight-text {
+		background-color: rgba(24, 144, 255, 0.2);
+	}
+
+	.custom-option {
+		&.focused,
+		&.ant-select-item-option-active {
+			background-color: #f5f5f5 !important;
+		}
+	}
+
+	.custom-select-dropdown-container {
+		.group-label,
+		.ant-select-item-group {
+			background-color: #f5f0f0;
+			border-bottom: 1px solid #e8e8e8;
+			box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+		}
+	}
+
+	// Light mode scrollbar overrides
+	.custom-select-dropdown,
+	.custom-multiselect-dropdown,
+	.custom-select-dropdown-container,
+	.custom-multiselect-dropdown-container {
+		scrollbar-color: rgba(0, 0, 0, 0.2) rgba(0, 0, 0, 0.05);
+
+		&::-webkit-scrollbar-track {
+			background-color: rgba(0, 0, 0, 0.05);
+		}
+
+		&::-webkit-scrollbar-thumb {
+			background-color: rgba(0, 0, 0, 0.2);
+
+			&:hover {
+				background-color: rgba(0, 0, 0, 0.3);
+			}
+		}
+	}
+}

frontend/src/components/NewSelect/types.ts

@@ -0,0 +1,60 @@
+import { SelectProps } from 'antd';
+
+export interface OptionData {
+	label: string;
+	value?: string;
+	disabled?: boolean;
+	className?: string;
+	style?: React.CSSProperties;
+	options?: OptionData[];
+	type?: 'defined' | 'custom' | 'regex';
+}
+
+export interface CustomSelectProps extends Omit<SelectProps, 'options'> {
+	placeholder?: string;
+	className?: string;
+	loading?: boolean;
+	onSearch?: (value: string) => void;
+	options?: OptionData[];
+	defaultActiveFirstOption?: boolean;
+	noDataMessage?: string;
+	onClear?: () => void;
+	getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+	dropdownRender?: (menu: React.ReactElement) => React.ReactElement;
+	highlightSearch?: boolean;
+	placement?: 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight';
+	popupMatchSelectWidth?: boolean;
+	errorMessage?: string;
+	allowClear?: SelectProps['allowClear'];
+	onRetry?: () => void;
+}
+
+export interface CustomTagProps {
+	label: React.ReactNode;
+	value: string;
+	closable: boolean;
+	onClose: () => void;
+}
+
+export interface CustomMultiSelectProps
+	extends Omit<SelectProps<string[] | string>, 'options'> {
+	placeholder?: string;
+	className?: string;
+	loading?: boolean;
+	onSearch?: (value: string) => void;
+	options?: OptionData[];
+	defaultActiveFirstOption?: boolean;
+	dropdownMatchSelectWidth?: boolean | number;
+	noDataMessage?: string;
+	onClear?: () => void;
+	enableAllSelection?: boolean;
+	getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+	dropdownRender?: (menu: React.ReactElement) => React.ReactElement;
+	highlightSearch?: boolean;
+	errorMessage?: string;
+	popupClassName?: string;
+	placement?: 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight';
+	maxTagCount?: number;
+	allowClear?: SelectProps['allowClear'];
+	onRetry?: () => void;
+}

frontend/src/components/NewSelect/utils.ts

@@ -0,0 +1,135 @@
+/* eslint-disable sonarjs/cognitive-complexity */
+import { OptionData } from './types';
+
+export const SPACEKEY = ' ';
+
+export const prioritizeOrAddOptionForSingleSelect = (
+	options: OptionData[],
+	value: string,
+	label?: string,
+): OptionData[] => {
+	let foundOption: OptionData | null = null;
+
+	// Separate the found option and the rest
+	const filteredOptions = options
+		.map((option) => {
+			if ('options' in option && Array.isArray(option.options)) {
+				// Filter out the value from nested options
+				const remainingSubOptions = option.options.filter(
+					(subOption) => subOption.value !== value,
+				);
+				const extractedOption = option.options.find(
+					(subOption) => subOption.value === value,
+				);
+
+				if (extractedOption) foundOption = extractedOption;
+
+				// Keep the group if it still has remaining options
+				return remainingSubOptions.length > 0
+					? { ...option, options: remainingSubOptions }
+					: null;
+			}
+
+			// Check top-level options
+			if (option.value === value) {
+				foundOption = option;
+				return null; // Remove it from the list
+			}
+
+			return option;
+		})
+		.filter(Boolean) as OptionData[]; // Remove null values
+
+	// If not found, create a new option
+	if (!foundOption) {
+		foundOption = { value, label: label ?? value };
+	}
+
+	// Add the found/new option at the top
+	return [foundOption, ...filteredOptions];
+};
+
+export const prioritizeOrAddOptionForMultiSelect = (
+	options: OptionData[],
+	values: string[], // Only supports multiple values (string[])
+	labels?: Record<string, string>,
+): OptionData[] => {
+	const foundOptions: OptionData[] = [];
+
+	// Separate the found options and the rest
+	const filteredOptions = options
+		.map((option) => {
+			if ('options' in option && Array.isArray(option.options)) {
+				// Filter out selected values from nested options
+				const remainingSubOptions = option.options.filter(
+					(subOption) => subOption.value && !values.includes(subOption.value),
+				);
+				const extractedOptions = option.options.filter(
+					(subOption) => subOption.value && values.includes(subOption.value),
+				);
+
+				if (extractedOptions.length > 0) {
+					foundOptions.push(...extractedOptions);
+				}
+
+				// Keep the group if it still has remaining options
+				return remainingSubOptions.length > 0
+					? { ...option, options: remainingSubOptions }
+					: null;
+			}
+
+			// Check top-level options
+			if (option.value && values.includes(option.value)) {
+				foundOptions.push(option);
+				return null; // Remove it from the list
+			}
+
+			return option;
+		})
+		.filter(Boolean) as OptionData[]; // Remove null values
+
+	// Find missing values that were not present in the original options and create new ones
+	const missingValues = values.filter(
+		(value) => !foundOptions.some((opt) => opt.value === value),
+	);
+
+	const newOptions = missingValues.map((value) => ({
+		value,
+		label: labels?.[value] ?? value, // Use provided label or default to value
+	}));
+
+	// Add found & new options to the top
+	return [...newOptions, ...foundOptions, ...filteredOptions];
+};
+
+/**
+ * Filters options based on search text
+ */
+export const filterOptionsBySearch = (
+	options: OptionData[],
+	searchText: string,
+): OptionData[] => {
+	if (!searchText.trim()) return options;
+
+	const lowerSearchText = searchText.toLowerCase();
+
+	return options
+		.map((option) => {
+			if ('options' in option && Array.isArray(option.options)) {
+				// Filter nested options
+				const filteredSubOptions = option.options.filter((subOption) =>
+					subOption.label.toLowerCase().includes(lowerSearchText),
+				);
+
+				return filteredSubOptions.length > 0
+					? { ...option, options: filteredSubOptions }
+					: undefined;
+			}
+
+			// Filter top-level options
+			return option.label.toLowerCase().includes(lowerSearchText)
+				? option
+				: undefined;
+		})
+		.filter(Boolean) as OptionData[];
+};

frontend/src/constants/routes.ts

@@ -17,7 +17,6 @@ const ROUTES = {
 		'/get-started/infrastructure-monitoring',
 	GET_STARTED_AWS_MONITORING: '/get-started/aws-monitoring',
 	GET_STARTED_AZURE_MONITORING: '/get-started/azure-monitoring',
-	USAGE_EXPLORER: '/usage-explorer',
 	APPLICATION: '/services',
 	ALL_DASHBOARD: '/dashboard',
 	DASHBOARD: '/dashboard/:dashboardId',

frontend/src/container/CustomDomainSettings/CustomDomainSettings.tsx

@@ -160,7 +160,7 @@ export default function CustomDomainSettings(): JSX.Element {
 				{!isLoadingDeploymentsData && (
 					<Card className="custom-domain-settings-card">
 						<div className="custom-domain-settings-content-header">
-							Team {org?.[0]?.name} Information
+							Team {org?.[0]?.displayName} Information
 						</div>
 
 						<div className="custom-domain-settings-content-body">

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

@@ -133,231 +133,3 @@ const ServicesListTable = memo(
 	),
 );
 ServicesListTable.displayName = 'ServicesListTable';
-
-function ServiceMetrics({
-	onUpdateChecklistDoneItem,
-	loadingUserPreferences,
-}: {
-	onUpdateChecklistDoneItem: (itemKey: string) => void;
-	loadingUserPreferences: boolean;
-}): JSX.Element {
-	const { selectedTime: globalSelectedInterval } = useSelector<
-		AppState,
-		GlobalReducer
-	>((state) => state.globalTime);
-
-	const { user, activeLicenseV3 } = useAppContext();
-
-	const [timeRange, setTimeRange] = useState(() => {
-		const now = new Date().getTime();
-		return {
-			startTime: now - homeInterval,
-			endTime: now,
-			selectedInterval: homeInterval,
-		};
-	});
-
-	const { queries } = useResourceAttribute();
-	const { safeNavigate } = useSafeNavigate();
-
-	const selectedTags = useMemo(
-		() => (convertRawQueriesToTraceSelectedTags(queries) as Tags[]) || [],
-		[queries],
-	);
-
-	const [isError, setIsError] = useState(false);
-
-	const queryKey: QueryKey = useMemo(
-		() => [
-			timeRange.startTime,
-			timeRange.endTime,
-			selectedTags,
-			globalSelectedInterval,
-		],
-		[
-			timeRange.startTime,
-			timeRange.endTime,
-			selectedTags,
-			globalSelectedInterval,
-		],
-	);
-
-	const {
-		data,
-		isLoading: isLoadingTopLevelOperations,
-		isError: isErrorTopLevelOperations,
-	} = useGetTopLevelOperations(queryKey, {
-		start: timeRange.startTime * 1e6,
-		end: timeRange.endTime * 1e6,
-	});
-
-	const handleTimeIntervalChange = useCallback((value: number): void => {
-		const timeInterval = TIME_PICKER_OPTIONS.find(
-			(option) => option.value === value,
-		);
-
-		logEvent('Homepage: Services time interval updated', {
-			updatedTimeInterval: timeInterval?.label,
-		});
-
-		const now = new Date();
-		setTimeRange({
-			startTime: now.getTime() - value,
-			endTime: now.getTime(),
-			selectedInterval: value,
-		});
-	}, []);
-
-	const topLevelOperations = useMemo(() => Object.entries(data || {}), [data]);
-
-	const queryRangeRequestData = useMemo(
-		() =>
-			getQueryRangeRequestData({
-				topLevelOperations,
-				minTime: timeRange.startTime * 1e6,
-				maxTime: timeRange.endTime * 1e6,
-				globalSelectedInterval,
-			}),
-		[
-			globalSelectedInterval,
-			timeRange.endTime,
-			timeRange.startTime,
-			topLevelOperations,
-		],
-	);
-
-	const dataQueries = useGetQueriesRange(
-		queryRangeRequestData,
-		ENTITY_VERSION_V4,
-		{
-			queryKey: useMemo(
-				() => [
-					`GetMetricsQueryRange-home-${globalSelectedInterval}`,
-					timeRange.endTime,
-					timeRange.startTime,
-					globalSelectedInterval,
-				],
-				[globalSelectedInterval, timeRange.endTime, timeRange.startTime],
-			),
-			keepPreviousData: true,
-			enabled: true,
-			refetchOnMount: false,
-			onError: () => {
-				setIsError(true);
-			},
-		},
-	);
-
-	const isLoading = useMemo(() => dataQueries.some((query) => query.isLoading), [
-		dataQueries,
-	]);
-
-	const services: ServicesList[] = useMemo(
-		() =>
-			getServiceListFromQuery({
-				queries: dataQueries,
-				topLevelOperations,
-				isLoading,
-			}),
-		[dataQueries, topLevelOperations, isLoading],
-	);
-
-	const sortedServices = useMemo(
-		() =>
-			services?.sort((a, b) => {
-				const aUpdateAt = new Date(a.p99).getTime();
-				const bUpdateAt = new Date(b.p99).getTime();
-				return bUpdateAt - aUpdateAt;
-			}) || [],
-		[services],
-	);
-
-	const servicesExist = sortedServices.length > 0;
-	const top5Services = useMemo(() => sortedServices.slice(0, 5), [
-		sortedServices,
-	]);
-
-	useEffect(() => {
-		if (!loadingUserPreferences && servicesExist) {
-			onUpdateChecklistDoneItem('SETUP_SERVICES');
-		}
-	}, [onUpdateChecklistDoneItem, loadingUserPreferences, servicesExist]);
-
-	const handleRowClick = useCallback(
-		(record: ServicesList) => {
-			logEvent('Homepage: Service clicked', {
-				serviceName: record.serviceName,
-			});
-			safeNavigate(`${ROUTES.APPLICATION}/${record.serviceName}`);
-		},
-		[safeNavigate],
-	);
-
-	if (isLoadingTopLevelOperations || isLoading) {
-		return (
-			<Card className="services-list-card home-data-card loading-card">
-				<Card.Content>
-					<Skeleton active />
-				</Card.Content>
-			</Card>
-		);
-	}
-
-	if (isErrorTopLevelOperations || isError) {
-		return (
-			<Card className="services-list-card home-data-card error-card">
-				<Card.Content>
-					<Skeleton active />
-				</Card.Content>
-			</Card>
-		);
-	}
-
-	return (
-		<Card className="services-list-card home-data-card">
-			{servicesExist && (
-				<Card.Header>
-					<div className="services-header home-data-card-header">
-						{' '}
-						Services
-						<div className="services-header-actions">
-							<Select
-								value={timeRange.selectedInterval}
-								onChange={handleTimeIntervalChange}
-								options={TIME_PICKER_OPTIONS}
-								className="services-header-select"
-							/>
-						</div>
-					</div>
-				</Card.Header>
-			)}
-			<Card.Content>
-				{servicesExist ? (
-					<ServicesListTable services={top5Services} onRowClick={handleRowClick} />
-				) : (
-					<EmptyState user={user} activeLicenseV3={activeLicenseV3} />
-				)}
-			</Card.Content>
-
-			{servicesExist && (
-				<Card.Footer>
-					<div className="services-footer home-data-card-footer">
-						<Link to="/services">
-							<Button
-								type="link"
-								className="periscope-btn link learn-more-link"
-								onClick={(): void => {
-									logEvent('Homepage: All Services clicked', {});
-								}}
-							>
-								All Services <ArrowRight size={12} />
-							</Button>
-						</Link>
-					</div>
-				</Card.Footer>
-			)}
-		</Card>
-	);
-}
-
-export default memo(ServiceMetrics);

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

@@ -21,17 +21,10 @@ function Services({
 	return (
 		<Sentry.ErrorBoundary fallback={<ErrorBoundaryFallback />}>
 			<div className="home-services-container">
-				{isSpanMetricEnabled ? (
-					<ServiceMetrics
+			<ServiceTraces
 						onUpdateChecklistDoneItem={onUpdateChecklistDoneItem}
 						loadingUserPreferences={loadingUserPreferences}
 					/>
-				) : (
-					<ServiceTraces
-						onUpdateChecklistDoneItem={onUpdateChecklistDoneItem}
-						loadingUserPreferences={loadingUserPreferences}
-					/>
-				)}
 			</div>
 		</Sentry.ErrorBoundary>
 	);

frontend/src/container/MetricsApplication/MetricsPageQueries/OverviewQueries.ts

@@ -481,7 +481,6 @@ export const apDexMetricsQueryBuilderQueries = ({
 export const operationPerSec = ({
 	servicename,
 	tagFilterItems,
-	topLevelOperations,
 }: OperationPerSecProps): QueryBuilderData => {
 	const autocompleteData: BaseAutocompleteData[] = [
 		{

frontend/src/container/MetricsApplication/Tabs/Overview.tsx

@@ -1,7 +1,4 @@
 import logEvent from 'api/common/logEvent';
-import getTopLevelOperations, {
-	ServiceDataProps,
-} from 'api/metrics/getTopLevelOperations';
 import { FeatureKeys } from 'constants/features';
 import { QueryParams } from 'constants/query';
 import { PANEL_TYPES } from 'constants/queryBuilder';
@@ -110,21 +107,6 @@ function Application(): JSX.Element {
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, []);
 
-	const {
-		data: topLevelOperations,
-		error: topLevelOperationsError,
-		isLoading: topLevelOperationsIsLoading,
-		isError: topLevelOperationsIsError,
-	} = useQuery<ServiceDataProps>({
-		queryKey: [servicename, minTime, maxTime],
-		queryFn: (): Promise<ServiceDataProps> =>
-			getTopLevelOperations({
-				service: servicename || '',
-				start: minTime,
-				end: maxTime,
-			}),
-	});
-
 	const selectedTraceTags: string = JSON.stringify(
 		convertRawQueriesToTraceSelectedTags(queries) || [],
 	);
@@ -137,14 +119,6 @@ function Application(): JSX.Element {
 		[queries],
 	);
 
-	const topLevelOperationsRoute = useMemo(
-		() =>
-			topLevelOperations
-				? defaultTo(topLevelOperations[servicename || ''], [])
-				: [],
-		[servicename, topLevelOperations],
-	);
-
 	const operationPerSecWidget = useMemo(
 		() =>
 			getWidgetQueryBuilder({

frontend/src/container/OnboardingQuestionaire/OrgQuestions/OrgQuestions.tsx

@@ -13,8 +13,7 @@ import { useTranslation } from 'react-i18next';
 
 export interface OrgData {
 	id: string;
-	isAnonymous: boolean;
-	name: string;
+	displayName: string;
 }
 
 export interface OrgDetails {
@@ -110,15 +109,14 @@ function OrgQuestions({
 		try {
 			setIsLoading(true);
 			const { statusCode, error } = await editOrg({
-				isAnonymous: currentOrgData.isAnonymous,
-				name: organisationName,
+				displayName: organisationName,
 				orgId: currentOrgData.id,
 			});
-			if (statusCode === 200) {
-				updateOrg(currentOrgData?.id, orgDetails.organisationName);
+			if (statusCode === 204) {
+				updateOrg(currentOrgData?.id, organisationName);
 
 				logEvent('Org Onboarding: Org Name Updated', {
-					organisationName: orgDetails.organisationName,
+					organisationName,
 				});
 
 				logEvent('Org Onboarding: Answered', {

frontend/src/container/OnboardingQuestionaire/index.tsx

@@ -94,7 +94,7 @@ function OnboardingQuestionaire(): JSX.Element {
 
 			setOrgDetails({
 				...orgDetails,
-				organisationName: org[0].name,
+				organisationName: org[0].displayName,
 			});
 		}
 		// eslint-disable-next-line react-hooks/exhaustive-deps

frontend/src/container/OnboardingV2Container/AddDataSource/AddDataSource.tsx

@@ -390,7 +390,7 @@ function OnboardingAddDataSource(): JSX.Element {
 		setSetupStepItems([
 			{
 				...setupStepItemsBase[0],
-				description: org?.[0]?.name || '',
+				description: org?.[0]?.displayName || '',
 			},
 			...setupStepItemsBase.slice(1),
 		]);
@@ -403,7 +403,7 @@ function OnboardingAddDataSource(): JSX.Element {
 			setSetupStepItems([
 				{
 					...setupStepItemsBase[0],
-					description: org?.[0]?.name || '',
+					description: org?.[0]?.displayName || '',
 				},
 				{
 					...setupStepItemsBase[1],
@@ -415,7 +415,7 @@ function OnboardingAddDataSource(): JSX.Element {
 			setSetupStepItems([
 				{
 					...setupStepItemsBase[0],
-					description: org?.[0]?.name || '',
+					description: org?.[0]?.displayName || '',
 				},
 				{
 					...setupStepItemsBase[1],

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

@@ -7,27 +7,22 @@ import { useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { requireErrorMessage } from 'utils/form/requireErrorMessage';
 
-function DisplayName({
-	index,
-	id: orgId,
-	isAnonymous,
-}: DisplayNameProps): JSX.Element {
+function DisplayName({ index, id: orgId }: DisplayNameProps): JSX.Element {
 	const [form] = Form.useForm<FormValues>();
-	const orgName = Form.useWatch('name', form);
+	const orgName = Form.useWatch('displayName', form);
 
 	const { t } = useTranslation(['organizationsettings', 'common']);
 	const { org, updateOrg } = useAppContext();
-	const { name } = (org || [])[index];
+	const { displayName } = (org || [])[index];
 	const [isLoading, setIsLoading] = useState<boolean>(false);
 	const { notifications } = useNotifications();
 
 	const onSubmit = async (values: FormValues): Promise<void> => {
 		try {
 			setIsLoading(true);
-			const { name } = values;
+			const { displayName } = values;
 			const { statusCode, error } = await editOrg({
-				isAnonymous,
-				name,
+				displayName,
 				orgId,
 			});
 			if (statusCode === 200) {
@@ -36,7 +31,7 @@ function DisplayName({
 						ns: 'common',
 					}),
 				});
-				updateOrg(orgId, name);
+				updateOrg(orgId, displayName);
 			} else {
 				notifications.error({
 					message:
@@ -61,18 +56,18 @@ function DisplayName({
 		return <div />;
 	}
 
-	const isDisabled = isLoading || orgName === name || !orgName;
+	const isDisabled = isLoading || orgName === displayName || !orgName;
 
 	return (
 		<Form
-			initialValues={{ name }}
+			initialValues={{ displayName }}
 			form={form}
 			layout="vertical"
 			onFinish={onSubmit}
 			autoComplete="off"
 		>
 			<Form.Item
-				name="name"
+				name="displayName"
 				label="Display name"
 				rules={[{ required: true, message: requireErrorMessage('Display name') }]}
 			>
@@ -95,11 +90,10 @@ function DisplayName({
 interface DisplayNameProps {
 	index: number;
 	id: IUser['id'];
-	isAnonymous: boolean;
 }
 
 interface FormValues {
-	name: string;
+	displayName: string;
 }
 
 export default DisplayName;

frontend/src/container/OrganizationSettings/index.tsx

@@ -23,12 +23,7 @@ function OrganizationSettings(): JSX.Element {
 		<>
 			<Space direction="vertical">
 				{org.map((e, index) => (
-					<DisplayName
-						isAnonymous={e.isAnonymous}
-						key={e.id}
-						id={e.id}
-						index={index}
-					/>
+					<DisplayName key={e.id} id={e.id} index={index} />
 				))}
 			</Space>
 			<Divider />

frontend/src/container/PlannedDowntime/PlannedDowntime.tsx

@@ -3,7 +3,7 @@ import 'dayjs/locale/en';
 
 import { PlusOutlined } from '@ant-design/icons';
 import { Color } from '@signozhq/design-tokens';
-import { Button, Flex, Form, Input, Typography } from 'antd';
+import { Button, Flex, Form, Input, Tooltip, Typography } from 'antd';
 import getAll from 'api/alerts/getAll';
 import { useDeleteDowntimeSchedule } from 'api/plannedDowntime/deleteDowntimeSchedule';
 import {
@@ -13,8 +13,10 @@ import {
 import dayjs from 'dayjs';
 import { useNotifications } from 'hooks/useNotifications';
 import { Search } from 'lucide-react';
+import { useAppContext } from 'providers/App/App';
 import React, { ChangeEvent, useEffect, useState } from 'react';
 import { useQuery } from 'react-query';
+import { USER_ROLES } from 'types/roles';
 
 import { PlannedDowntimeDeleteModal } from './PlannedDowntimeDeleteModal';
 import { PlannedDowntimeForm } from './PlannedDowntimeForm';
@@ -33,6 +35,7 @@ export function PlannedDowntime(): JSX.Element {
 	});
 	const [isOpen, setIsOpen] = React.useState(false);
 	const [form] = Form.useForm();
+	const { user } = useAppContext();
 
 	const [initialValues, setInitialValues] = useState<
 		Partial<DowntimeSchedules & { editMode: boolean }>
@@ -108,18 +111,27 @@ export function PlannedDowntime(): JSX.Element {
 						value={searchValue}
 						onChange={handleSearch}
 					/>
-					<Button
-						icon={<PlusOutlined />}
-						type="primary"
-						onClick={(): void => {
-							setInitialValues({ ...defautlInitialValues, editMode: false });
-							setIsOpen(true);
-							setEditMode(false);
-							form.resetFields();
-						}}
+					<Tooltip
+						title={
+							user?.role === USER_ROLES.VIEWER
+								? 'You need edit permissions to create a planned downtime'
+								: ''
+						}
 					>
-						New downtime
-					</Button>
+						<Button
+							icon={<PlusOutlined />}
+							type="primary"
+							onClick={(): void => {
+								setInitialValues({ ...defautlInitialValues, editMode: false });
+								setIsOpen(true);
+								setEditMode(false);
+								form.resetFields();
+							}}
+							disabled={user?.role === USER_ROLES.VIEWER}
+						>
+							New downtime
+						</Button>
+					</Tooltip>
 				</Flex>
 				<br />
 				<PlannedDowntimeList

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

@@ -0,0 +1,44 @@
+import { screen } from '@testing-library/react';
+import { render } from 'tests/test-utils';
+import { USER_ROLES } from 'types/roles';
+
+import { PlannedDowntime } from '../PlannedDowntime';
+
+describe('PlannedDowntime Component', () => {
+	it('renders the PlannedDowntime component properly', () => {
+		render(<PlannedDowntime />, {}, 'ADMIN');
+
+		// Check if title is rendered
+		expect(screen.getByText('Planned Downtime')).toBeInTheDocument();
+
+		// Check if subtitle is rendered
+		expect(
+			screen.getByText('Create and manage planned downtimes.'),
+		).toBeInTheDocument();
+
+		// Check if search input is rendered
+		expect(
+			screen.getByPlaceholderText('Search for a planned downtime...'),
+		).toBeInTheDocument();
+
+		// Check if "New downtime" button is enabled for ADMIN
+		const newDowntimeButton = screen.getByRole('button', {
+			name: /new downtime/i,
+		});
+		expect(newDowntimeButton).toBeInTheDocument();
+		expect(newDowntimeButton).not.toBeDisabled();
+	});
+
+	it('disables the "New downtime" button for users with VIEWER role', () => {
+		render(<PlannedDowntime />, {}, USER_ROLES.VIEWER);
+
+		// Check if "New downtime" button is disabled for VIEWER
+		const newDowntimeButton = screen.getByRole('button', {
+			name: /new downtime/i,
+		});
+		expect(newDowntimeButton).toBeInTheDocument();
+		expect(newDowntimeButton).toBeDisabled();
+
+		expect(newDowntimeButton).toHaveAttribute('disabled');
+	});
+});

frontend/src/modules/Usage/UsageExplorer.tsx

@@ -1,224 +0,0 @@
-/* eslint-disable */
-//@ts-nocheck
-
-import { Select, Space, Typography } from 'antd';
-import Graph from 'components/Graph';
-import { useEffect, useState } from 'react';
-import { connect, useSelector } from 'react-redux';
-import { withRouter } from 'react-router-dom';
-import { GetService, getUsageData, UsageDataItem } from 'store/actions';
-import { AppState } from 'store/reducers';
-import { GlobalTime } from 'types/actions/globalTime';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import MetricReducer from 'types/reducer/metrics';
-import { isOnboardingSkipped } from 'utils/app';
-
-import { Card } from './styles';
-
-const { Option } = Select;
-
-interface UsageExplorerProps {
-	usageData: UsageDataItem[];
-	getUsageData: (
-		minTime: number,
-		maxTime: number,
-		selectedInterval: number,
-		selectedService: string,
-	) => void;
-	getServicesList: ({
-		selectedTimeInterval,
-	}: {
-		selectedTimeInterval: GlobalReducer['selectedTime'];
-	}) => void;
-	globalTime: GlobalTime;
-	servicesList: servicesListItem[];
-	totalCount: number;
-}
-const timeDaysOptions = [
-	{ value: 30, label: 'Last 30 Days' },
-	{ value: 7, label: 'Last week' },
-	{ value: 1, label: 'Last day' },
-];
-
-const interval = [
-	{
-		value: 604800,
-		chartDivideMultiplier: 1,
-		label: 'Weekly',
-		applicableOn: [timeDaysOptions[0]],
-	},
-	{
-		value: 86400,
-		chartDivideMultiplier: 30,
-		label: 'Daily',
-		applicableOn: [timeDaysOptions[0], timeDaysOptions[1]],
-	},
-	{
-		value: 3600,
-		chartDivideMultiplier: 10,
-		label: 'Hours',
-		applicableOn: [timeDaysOptions[2], timeDaysOptions[1]],
-	},
-];
-
-function _UsageExplorer(props: UsageExplorerProps): JSX.Element {
-	const [selectedTime, setSelectedTime] = useState(timeDaysOptions[1]);
-	const [selectedInterval, setSelectedInterval] = useState(interval[2]);
-	const [selectedService, setSelectedService] = useState<string>('');
-	const { selectedTime: globalSelectedTime } = useSelector<
-		AppState,
-		GlobalReducer
-	>((state) => state.globalTime);
-	const {
-		getServicesList,
-		getUsageData,
-		globalTime,
-		totalCount,
-		usageData,
-	} = props;
-	const { services } = useSelector<AppState, MetricReducer>(
-		(state) => state.metrics,
-	);
-
-	useEffect(() => {
-		if (selectedTime && selectedInterval) {
-			const maxTime = new Date().getTime() * 1000000;
-			const minTime = maxTime - selectedTime.value * 24 * 3600000 * 1000000;
-
-			getUsageData(minTime, maxTime, selectedInterval.value, selectedService);
-		}
-	}, [selectedTime, selectedInterval, selectedService, getUsageData]);
-
-	useEffect(() => {
-		getServicesList({
-			selectedTimeInterval: globalSelectedTime,
-		});
-	}, [globalTime, getServicesList, globalSelectedTime]);
-
-	const data = {
-		labels: usageData.map((s) => new Date(s.timestamp / 1000000)),
-		datasets: [
-			{
-				label: 'Span Count',
-				data: usageData.map((s) => s.count),
-				backgroundColor: 'rgba(255, 99, 132, 0.2)',
-				borderColor: 'rgba(255, 99, 132, 1)',
-				borderWidth: 2,
-			},
-		],
-	};
-
-	return (
-		<>
-			<Space style={{ marginTop: 40, marginLeft: 20 }}>
-				<Space>
-					<Select
-						onSelect={(value): void => {
-							setSelectedTime(
-								timeDaysOptions.filter((item) => item.value == parseInt(value))[0],
-							);
-						}}
-						value={selectedTime.label}
-					>
-						{timeDaysOptions.map(({ value, label }) => (
-							<Option key={value} value={value}>
-								{label}
-							</Option>
-						))}
-					</Select>
-				</Space>
-				<Space>
-					<Select
-						onSelect={(value): void => {
-							setSelectedInterval(
-								interval.filter((item) => item.value === parseInt(value))[0],
-							);
-						}}
-						value={selectedInterval.label}
-					>
-						{interval
-							.filter((interval) => interval.applicableOn.includes(selectedTime))
-							.map((item) => (
-								<Option key={item.label} value={item.value}>
-									{item.label}
-								</Option>
-							))}
-					</Select>
-				</Space>
-
-				<Space>
-					<Select
-						onSelect={(value): void => {
-							setSelectedService(value);
-						}}
-						value={selectedService || 'All Services'}
-					>
-						<Option value="">All Services</Option>
-						{services?.map((service) => (
-							<Option key={service.serviceName} value={service.serviceName}>
-								{service.serviceName}
-							</Option>
-						))}
-					</Select>
-				</Space>
-
-				{isOnboardingSkipped() && totalCount === 0 ? (
-					<Space
-						style={{
-							width: '100%',
-							margin: '40px 0',
-							marginLeft: 20,
-							justifyContent: 'center',
-						}}
-					>
-						<Typography>
-							No spans found. Please add instrumentation (follow this
-							<a
-								href="https://signoz.io/docs/instrumentation/overview"
-								target="_blank"
-								style={{ marginLeft: 3 }}
-								rel="noreferrer"
-							>
-								guide
-							</a>
-							)
-						</Typography>
-					</Space>
-				) : (
-					<Space style={{ display: 'block', marginLeft: 20, width: 200 }}>
-						<Typography>{`Total count is ${totalCount}`}</Typography>
-					</Space>
-				)}
-			</Space>
-
-			<Card>
-				<Graph name="usage" data={data} type="bar" />
-			</Card>
-		</>
-	);
-}
-
-const mapStateToProps = (
-	state: AppState,
-): {
-	totalCount: number;
-	globalTime: GlobalTime;
-	usageData: UsageDataItem[];
-} => {
-	let totalCount = 0;
-	for (const item of state.usageDate) {
-		totalCount += item.count;
-	}
-	return {
-		totalCount,
-		usageData: state.usageDate,
-		globalTime: state.globalTime,
-	};
-};
-
-export const UsageExplorer = withRouter(
-	connect(mapStateToProps, {
-		getUsageData,
-		getServicesList: GetService,
-	})(_UsageExplorer),
-);

frontend/src/modules/Usage/index.tsx

@@ -1,7 +0,0 @@
-import { UsageExplorer } from './UsageExplorer';
-
-function UsageExplorerContainer(): JSX.Element {
-	return <UsageExplorer />;
-}
-
-export default UsageExplorerContainer;

frontend/src/modules/Usage/styles.ts

@@ -1,13 +0,0 @@
-import { Card as CardComponent } from 'antd';
-import styled from 'styled-components';
-
-export const Card = styled(CardComponent)`
-	&&& {
-		width: 90%;
-		margin-top: 2rem;
-	}
-
-	.ant-card-body {
-		height: 70vh;
-	}
-`;

frontend/src/pages/SignUp/SignUp.tsx

@@ -1,4 +1,4 @@
-import { Button, Form, Input, Space, Switch, Typography } from 'antd';
+import { Button, Form, Input, Typography } from 'antd';
 import logEvent from 'api/common/logEvent';
 import getInviteDetails from 'api/user/getInviteDetails';
 import loginApi from 'api/user/login';
@@ -14,13 +14,7 @@ import { useQuery } from 'react-query';
 import { useLocation } from 'react-router-dom';
 import { PayloadProps as LoginPrecheckPayloadProps } from 'types/api/user/loginPrecheck';
 
-import {
-	ButtonContainer,
-	FormContainer,
-	FormWrapper,
-	Label,
-	MarginTop,
-} from './styles';
+import { ButtonContainer, FormContainer, FormWrapper, Label } from './styles';
 import { isPasswordNotValidMessage, isPasswordValid } from './utils';
 
 const { Title } = Typography;
@@ -111,24 +105,15 @@ function SignUp({ version }: SignUpProps): JSX.Element {
 
 	const isPreferenceVisible = token === null;
 
-	const commonHandler = async (
-		values: FormValues,
-		isPreferenceVisible: boolean,
-	): Promise<void> => {
+	const commonHandler = async (values: FormValues): Promise<void> => {
 		try {
 			const { organizationName, password, firstName, email } = values;
 			const response = await signUpApi({
 				email,
 				name: firstName,
-				orgName: organizationName,
+				orgDisplayName: organizationName,
 				password,
 				token: params.get('token') || undefined,
-				...(isPreferenceVisible
-					? {
-							isAnonymous: values.isAnonymous,
-							hasOptedUpdates: values.hasOptedUpdates,
-					  }
-					: {}),
 			});
 
 			if (response.statusCode === 200) {
@@ -171,7 +156,7 @@ function SignUp({ version }: SignUpProps): JSX.Element {
 			const response = await signUpApi({
 				email: values.email,
 				name: values.firstName,
-				orgName: values.organizationName,
+				orgDisplayName: values.organizationName,
 				password: values.password,
 				token: params.get('token') || undefined,
 				sourceUrl: encodeURIComponent(window.location.href),
@@ -221,14 +206,14 @@ function SignUp({ version }: SignUpProps): JSX.Element {
 				}
 
 				if (isPreferenceVisible) {
-					await commonHandler(values, true);
+					await commonHandler(values);
 				} else {
 					logEvent('Account Created Successfully', {
 						email: values.email,
 						name: values.firstName,
 					});
 
-					await commonHandler(values, false);
+					await commonHandler(values);
 				}
 
 				setLoading(false);
@@ -278,7 +263,6 @@ function SignUp({ version }: SignUpProps): JSX.Element {
 				<FormContainer
 					onFinish={!precheck.sso ? handleSubmit : handleSubmitSSO}
 					onValuesChange={handleValuesChange}
-					initialValues={{ hasOptedUpdates: true, isAnonymous: false }}
 					form={form}
 				>
 					<Title level={4}>Create your account</Title>
@@ -359,34 +343,6 @@ function SignUp({ version }: SignUpProps): JSX.Element {
 							)}
 						</div>
 					)}
-
-					{isPreferenceVisible && (
-						<>
-							<MarginTop marginTop="2.4375rem">
-								<Space>
-									<FormContainer.Item
-										noStyle
-										name="hasOptedUpdates"
-										valuePropName="checked"
-									>
-										<Switch />
-									</FormContainer.Item>
-
-									<Typography>{t('prompt_keepme_posted')} </Typography>
-								</Space>
-							</MarginTop>
-
-							<MarginTop marginTop="0.5rem">
-								<Space>
-									<FormContainer.Item noStyle name="isAnonymous" valuePropName="checked">
-										<Switch />
-									</FormContainer.Item>
-									<Typography>{t('prompt_anonymise')}</Typography>
-								</Space>
-							</MarginTop>
-						</>
-					)}
-
 					{isPreferenceVisible && (
 						<Typography.Paragraph
 							italic

frontend/src/providers/App/App.tsx

@@ -82,10 +82,8 @@ export function AppProvider({ children }: PropsWithChildren): JSX.Element {
 					return [
 						{
 							createdAt: 0,
-							hasOptedUpdates: false,
 							id: userData.payload.orgId,
-							isAnonymous: false,
-							name: userData.payload.organization,
+							displayName: userData.payload.organization,
 						},
 					];
 				}
@@ -95,10 +93,8 @@ export function AppProvider({ children }: PropsWithChildren): JSX.Element {
 					...prev.slice(0, orgIndex),
 					{
 						createdAt: 0,
-						hasOptedUpdates: false,
 						id: userData.payload.orgId,
-						isAnonymous: false,
-						name: userData.payload.organization,
+						displayName: userData.payload.organization,
 					},
 					...prev.slice(orgIndex + 1, prev.length),
 				];
@@ -209,10 +205,8 @@ export function AppProvider({ children }: PropsWithChildren): JSX.Element {
 					...org.slice(0, orgIndex),
 					{
 						createdAt: 0,
-						hasOptedUpdates: false,
 						id: orgId,
-						isAnonymous: false,
-						name: updatedOrgName,
+						displayName: updatedOrgName,
 					},
 					...org.slice(orgIndex + 1, org.length),
 				];

frontend/src/providers/App/utils.ts

@@ -23,7 +23,6 @@ function getUserDefaults(): IUser {
 		organization: '',
 		orgId: '',
 		role: 'VIEWER',
-		groupId: '',
 	};
 }
 

frontend/src/store/actions/index.ts

@@ -2,4 +2,3 @@ export * from './global';
 export * from './metrics';
 export * from './serviceMap';
 export * from './types';
-export * from './usage';

frontend/src/store/actions/logs/getLogs.ts

@@ -1,34 +0,0 @@
-import GetLogs from 'api/logs/GetLogs';
-import { Dispatch } from 'redux';
-import AppActions from 'types/actions';
-import { SET_LOADING, SET_LOGS } from 'types/actions/logs';
-import { Props } from 'types/api/logs/getLogs';
-
-export const getLogs = (
-	props: Props,
-): ((dispatch: Dispatch<AppActions>) => void) => async (
-	dispatch,
-): Promise<void> => {
-	dispatch({
-		type: SET_LOADING,
-		payload: true,
-	});
-
-	const response = await GetLogs(props);
-
-	if (response.payload)
-		dispatch({
-			type: SET_LOGS,
-			payload: response.payload,
-		});
-	else
-		dispatch({
-			type: SET_LOGS,
-			payload: [],
-		});
-
-	dispatch({
-		type: SET_LOADING,
-		payload: false,
-	});
-};

frontend/src/store/actions/types.ts

@@ -1,17 +1,14 @@
 import { ServiceMapItemAction, ServiceMapLoading } from './serviceMap';
-import { GetUsageDataAction } from './usage';
 
 export enum ActionTypes {
 	updateTimeInterval = 'UPDATE_TIME_INTERVAL',
 	getServiceMapItems = 'GET_SERVICE_MAP_ITEMS',
 	getServices = 'GET_SERVICES',
-	getUsageData = 'GET_USAGE_DATE',
 	fetchTraces = 'FETCH_TRACES',
 	fetchTraceItem = 'FETCH_TRACE_ITEM',
 	serviceMapLoading = 'UPDATE_SERVICE_MAP_LOADING',
 }
 
 export type Action =
-	| GetUsageDataAction
 	| ServiceMapItemAction
 	| ServiceMapLoading;

frontend/src/store/actions/usage.ts

@@ -1,34 +0,0 @@
-import api from 'api';
-import { Dispatch } from 'redux';
-import { toUTCEpoch } from 'utils/timeUtils';
-
-import { ActionTypes } from './types';
-
-export interface UsageDataItem {
-	timestamp: number;
-	count: number;
-}
-
-export interface GetUsageDataAction {
-	type: ActionTypes.getUsageData;
-	payload: UsageDataItem[];
-}
-
-export const getUsageData = (
-	minTime: number,
-	maxTime: number,
-	step: number,
-	service: string,
-) => async (dispatch: Dispatch): Promise<void> => {
-	const requesString = `/usage?start=${toUTCEpoch(minTime)}&end=${toUTCEpoch(
-		maxTime,
-	)}&step=${step}&service=${service || ''}`;
-	// Step can only be multiple of 3600
-	const response = await api.get<UsageDataItem[]>(requesString);
-
-	dispatch<GetUsageDataAction>({
-		type: ActionTypes.getUsageData,
-		payload: response.data,
-		// PNOTE - response.data in the axios response has the actual API response
-	});
-};

frontend/src/store/reducers/index.ts

@@ -6,11 +6,9 @@ import { LogsReducer } from './logs';
 import metricsReducers from './metric';
 import { ServiceMapReducer } from './serviceMap';
 import traceReducer from './trace';
-import { usageDataReducer } from './usage';
 
 const reducers = combineReducers({
 	traces: traceReducer,
-	usageDate: usageDataReducer,
 	globalTime: globalTimeReducer,
 	serviceMap: ServiceMapReducer,
 	app: appReducer,

frontend/src/store/reducers/usage.ts

@@ -1,14 +0,0 @@
-/* eslint-disable sonarjs/no-small-switch */
-import { Action, ActionTypes, UsageDataItem } from 'store/actions';
-
-export const usageDataReducer = (
-	state: UsageDataItem[] = [{ timestamp: 0, count: 0 }],
-	action: Action,
-): UsageDataItem[] => {
-	switch (action.type) {
-		case ActionTypes.getUsageData:
-			return action.payload;
-		default:
-			return state;
-	}
-};

frontend/src/tests/test-utils.tsx

@@ -151,15 +151,12 @@ export function getAppContextMock(
 			organization: 'Nightswatch',
 			orgId: 'does-not-matter-id',
 			role: role as ROLES,
-			groupId: 'does-not-matter-groupId',
 		},
 		org: [
 			{
 				createdAt: 0,
-				hasOptedUpdates: false,
 				id: 'does-not-matter-id',
-				isAnonymous: false,
-				name: 'Pentagon',
+				displayName: 'Pentagon',
 			},
 		],
 		isFetchingUser: false,

frontend/src/types/api/user/editOrg.ts

@@ -1,8 +1,6 @@
 export interface Props {
-	name: string;
-	isAnonymous: boolean;
+	displayName: string;
 	orgId: string;
-	hasOptedUpdates?: boolean;
 }
 
 export interface PayloadProps {

frontend/src/types/api/user/getInviteDetails.ts

@@ -14,6 +14,6 @@ export interface PayloadProps {
 	name: User['name'];
 	role: ROLES;
 	token: string;
-	organization: Organization['name'];
+	organization: Organization['displayName'];
 	precheck?: LoginPrecheckPayloadProps;
 }

frontend/src/types/api/user/getOrganization.ts

@@ -1,9 +1,7 @@
 export interface Organization {
 	createdAt: number;
-	hasOptedUpdates: boolean;
 	id: string;
-	isAnonymous: boolean;
-	name: string;
+	displayName: string;
 }
 
 export type PayloadProps = Organization[];

frontend/src/types/api/user/getUser.ts

@@ -15,5 +15,4 @@ export interface PayloadProps {
 	profilePictureURL: string;
 	organization: string;
 	role: ROLES;
-	groupId: string;
 }

frontend/src/types/api/user/signup.ts

@@ -1,10 +1,8 @@
 export interface Props {
 	name: string;
-	orgName: string;
+	orgDisplayName: string;
 	email: string;
 	password: string;
 	token?: string;
 	sourceUrl?: string;
-	isAnonymous?: boolean;
-	hasOptedUpdates?: boolean;
 }

frontend/src/types/common/index.ts

@@ -2,6 +2,8 @@ export type Created = 201;
 
 export type Success = 200;
 
+export type SuccessNoContent = 204;
+
 export type Forbidden = 403;
 
 export type BadRequest = 400;
@@ -14,7 +16,7 @@ export type Conflict = 409;
 
 export type ServerError = 500;
 
-export type SuccessStatusCode = Created | Success;
+export type SuccessStatusCode = Created | Success | SuccessNoContent;
 
 export type ErrorStatusCode =
 	| Forbidden

frontend/tests/fixtures/common.ts

@@ -33,7 +33,7 @@ export const loginApi = async (page: Page): Promise<void> => {
 				body: JSON.stringify(loginApiResponse),
 			}),
 		),
-		page.route(`**/org/${userLoginResponse.orgId}`, (route) =>
+		page.route(`**/orgs/me`, (route) =>
 			route.fulfill({
 				status: 200,
 				body: JSON.stringify(updateOrgResponse),

frontend/yarn.lock

@@ -5522,10 +5522,10 @@ axe-core@^4.6.2:
   resolved "https://registry.npmjs.org/axe-core/-/axe-core-4.7.0.tgz"
   integrity sha512-M0JtH+hlOL5pLQwHOLNYZaXuhqmvS8oExsqB1SBYgA4Dk7u/xx+YdGHXaK5pyUfed5mYXdlYiphWq3G8cRi5JQ==
 
-axios@1.7.7:
-  version "1.7.7"
-  resolved "https://registry.yarnpkg.com/axios/-/axios-1.7.7.tgz#2f554296f9892a72ac8d8e4c5b79c14a91d0a47f"
-  integrity sha512-S4kL7XrjgBmvdGut0sN3yJxqYzrDOnivkBiN0OFs6hLiUam3UPvswUo0kqGyhqUZGEOytHyumEdXsAkgCOUf3Q==
+axios@1.8.2:
+  version "1.8.2"
+  resolved "https://registry.yarnpkg.com/axios/-/axios-1.8.2.tgz#fabe06e241dfe83071d4edfbcaa7b1c3a40f7979"
+  integrity sha512-ls4GYBm5aig9vWx8AWDSGLpnpDQRtWAfrjU+EuytuODrFBkqesN2RkOQCBzrA1RQNHw1SmRMSDDDSwzNAYQ6Rg==
   dependencies:
     follow-redirects "^1.15.6"
     form-data "^4.0.0"

pkg/alertmanager/api.go

@@ -28,9 +28,9 @@ func (api *API) GetAlerts(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
-	claims, ok := authtypes.ClaimsFromContext(ctx)
-	if !ok {
-		render.Error(rw, errors.Newf(errors.TypeUnauthenticated, errors.CodeUnauthenticated, "unauthenticated"))
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
 		return
 	}
 
@@ -53,9 +53,9 @@ func (api *API) TestReceiver(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
-	claims, ok := authtypes.ClaimsFromContext(ctx)
-	if !ok {
-		render.Error(rw, errors.Newf(errors.TypeUnauthenticated, errors.CodeUnauthenticated, "unauthenticated"))
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
 		return
 	}
 
@@ -85,9 +85,9 @@ func (api *API) ListChannels(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
-	claims, ok := authtypes.ClaimsFromContext(ctx)
-	if !ok {
-		render.Error(rw, errors.Newf(errors.TypeUnauthenticated, errors.CodeUnauthenticated, "unauthenticated"))
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
 		return
 	}
 
@@ -122,9 +122,9 @@ func (api *API) GetChannelByID(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
-	claims, ok := authtypes.ClaimsFromContext(ctx)
-	if !ok {
-		render.Error(rw, errors.Newf(errors.TypeUnauthenticated, errors.CodeUnauthenticated, "unauthenticated"))
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
 		return
 	}
 
@@ -159,9 +159,9 @@ func (api *API) UpdateChannelByID(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
-	claims, ok := authtypes.ClaimsFromContext(ctx)
-	if !ok {
-		render.Error(rw, errors.Newf(errors.TypeUnauthenticated, errors.CodeUnauthenticated, "unauthenticated"))
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
 		return
 	}
 
@@ -209,9 +209,9 @@ func (api *API) DeleteChannelByID(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
-	claims, ok := authtypes.ClaimsFromContext(ctx)
-	if !ok {
-		render.Error(rw, errors.Newf(errors.TypeUnauthenticated, errors.CodeUnauthenticated, "unauthenticated"))
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
 		return
 	}
 
@@ -246,9 +246,9 @@ func (api *API) CreateChannel(rw http.ResponseWriter, req *http.Request) {
 	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
 	defer cancel()
 
-	claims, ok := authtypes.ClaimsFromContext(ctx)
-	if !ok {
-		render.Error(rw, errors.Newf(errors.TypeUnauthenticated, errors.CodeUnauthenticated, "unauthenticated"))
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
 		return
 	}
 

pkg/errors/code.go

@@ -6,31 +6,31 @@ import (
 )
 
 var (
-	CodeInvalidInput     code = code{"invalid_input"}
-	CodeInternal              = code{"internal"}
-	CodeUnsupported           = code{"unsupported"}
-	CodeNotFound              = code{"not_found"}
-	CodeMethodNotAllowed      = code{"method_not_allowed"}
-	CodeAlreadyExists         = code{"already_exists"}
-	CodeUnauthenticated       = code{"unauthenticated"}
-	CodeForbidden             = code{"forbidden"}
+	CodeInvalidInput     Code = Code{"invalid_input"}
+	CodeInternal              = Code{"internal"}
+	CodeUnsupported           = Code{"unsupported"}
+	CodeNotFound              = Code{"not_found"}
+	CodeMethodNotAllowed      = Code{"method_not_allowed"}
+	CodeAlreadyExists         = Code{"already_exists"}
+	CodeUnauthenticated       = Code{"unauthenticated"}
+	CodeForbidden             = Code{"forbidden"}
 )
 
 var (
 	codeRegex = regexp.MustCompile(`^[a-z_]+$`)
 )
 
-type code struct{ s string }
+type Code struct{ s string }
 
-func NewCode(s string) (code, error) {
+func NewCode(s string) (Code, error) {
 	if !codeRegex.MatchString(s) {
-		return code{}, fmt.Errorf("invalid code: %v", s)
+		return Code{}, fmt.Errorf("invalid code: %v", s)
 	}
 
-	return code{s: s}, nil
+	return Code{s: s}, nil
 }
 
-func MustNewCode(s string) code {
+func MustNewCode(s string) Code {
 	code, err := NewCode(s)
 	if err != nil {
 		panic(err)
@@ -39,6 +39,6 @@ func MustNewCode(s string) code {
 	return code
 }
 
-func (c code) String() string {
+func (c Code) String() string {
 	return c.s
 }

pkg/errors/errors.go

@@ -7,7 +7,7 @@ import (
 )
 
 var (
-	codeUnknown code = MustNewCode("unknown")
+	codeUnknown Code = MustNewCode("unknown")
 )
 
 // base is the fundamental struct that implements the error interface.
@@ -16,7 +16,7 @@ type base struct {
 	// t denotes the custom type of the error.
 	t typ
 	// c denotes the short code for the error message.
-	c code
+	c Code
 	// m contains error message passed through errors.New.
 	m string
 	// e is the actual error being wrapped.
@@ -47,7 +47,7 @@ func (b *base) Error() string {
 }
 
 // New returns a base error. It requires type, code and message as input.
-func New(t typ, code code, message string) *base {
+func New(t typ, code Code, message string) *base {
 	return &base{
 		t: t,
 		c: code,
@@ -59,7 +59,7 @@ func New(t typ, code code, message string) *base {
 }
 
 // Newf returns a new base by formatting the error message with the supplied format specifier.
-func Newf(t typ, code code, format string, args ...interface{}) *base {
+func Newf(t typ, code Code, format string, args ...interface{}) *base {
 	return &base{
 		t: t,
 		c: code,
@@ -70,7 +70,7 @@ func Newf(t typ, code code, format string, args ...interface{}) *base {
 
 // Wrapf returns a new error by formatting the error message with the supplied format specifier
 // and wrapping another error with base.
-func Wrapf(cause error, t typ, code code, format string, args ...interface{}) *base {
+func Wrapf(cause error, t typ, code Code, format string, args ...interface{}) *base {
 	return &base{
 		t: t,
 		c: code,
@@ -110,7 +110,7 @@ func (b *base) WithAdditional(a ...string) *base {
 // and the error itself.
 //
 //lint:ignore ST1008 we want to return arguments in the 'TCMEUA' order of the struct
-func Unwrapb(cause error) (typ, code, string, error, string, []string) {
+func Unwrapb(cause error) (typ, Code, string, error, string, []string) {
 	base, ok := cause.(*base)
 	if ok {
 		return base.t, base.c, base.m, base.e, base.u, base.a
@@ -127,7 +127,7 @@ func Ast(cause error, typ typ) bool {
 }
 
 // Ast checks if the provided error matches the specified custom error code.
-func Asc(cause error, code code) bool {
+func Asc(cause error, code Code) bool {
 	_, c, _, _, _, _ := Unwrapb(cause)
 
 	return c.s == code.s
@@ -137,3 +137,7 @@ func Asc(cause error, code code) bool {
 func Join(errs ...error) error {
 	return errors.Join(errs...)
 }
+
+func As(err error, target any) bool {
+	return errors.As(err, target)
+}

pkg/http/middleware/analytics.go

@@ -46,8 +46,8 @@ func (a *Analytics) Wrap(next http.Handler) http.Handler {
 		}
 
 		if _, ok := telemetry.EnabledPaths()[path]; ok {
-			claims, ok := authtypes.ClaimsFromContext(r.Context())
-			if ok {
+			claims, err := authtypes.ClaimsFromContext(r.Context())
+			if err == nil {
 				telemetry.GetInstance().SendEvent(telemetry.TELEMETRY_EVENT_PATH, data, claims.Email, true, false)
 			}
 		}
@@ -134,8 +134,8 @@ func (a *Analytics) extractQueryRangeData(path string, r *http.Request) (map[str
 		data["queryType"] = queryInfoResult.QueryType
 		data["panelType"] = queryInfoResult.PanelType
 
-		claims, ok := authtypes.ClaimsFromContext(r.Context())
-		if ok {
+		claims, err := authtypes.ClaimsFromContext(r.Context())
+		if err == nil {
 			// switch case to set data["screen"] based on the referrer
 			switch {
 			case dashboardMatched:

pkg/http/middleware/auth.go

@@ -28,9 +28,7 @@ func (a *Auth) Wrap(next http.Handler) http.Handler {
 			values = append(values, r.Header.Get(header))
 		}
 
-		ctx, err := a.jwt.ContextFromRequest(
-			r.Context(),
-			values...)
+		ctx, err := a.jwt.ContextFromRequest(r.Context(), values...)
 		if err != nil {
 			next.ServeHTTP(w, r)
 			return

pkg/http/middleware/authz.go

@@ -0,0 +1,105 @@
+package middleware
+
+import (
+	"log/slog"
+	"net/http"
+
+	"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
+}
+
+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)
+	})
+}

pkg/http/middleware/logging.go

@@ -136,8 +136,8 @@ func (middleware *Logging) getLogCommentKVs(r *http.Request) map[string]string {
 	}
 
 	var email string
-	claims, ok := authtypes.ClaimsFromContext(r.Context())
-	if ok {
+	claims, err := authtypes.ClaimsFromContext(r.Context())
+	if err == nil {
 		email = claims.Email
 	}
 

pkg/http/render/render.go

@@ -58,6 +58,8 @@ func Error(rw http.ResponseWriter, cause error) {
 		httpCode = http.StatusUnauthorized
 	case errors.TypeUnsupported:
 		httpCode = http.StatusNotImplemented
+	case errors.TypeForbidden:
+		httpCode = http.StatusForbidden
 	}
 
 	rea := make([]responseerroradditional, len(a))

pkg/modules/organization/implorganization/handler.go

@@ -0,0 +1,80 @@
+package implorganization
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type handler struct {
+	module organization.Module
+}
+
+func NewHandler(module organization.Module) organization.Handler {
+	return &handler{module: module}
+}
+
+func (handler *handler) Get(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "orgId is invalid"))
+		return
+	}
+
+	organization, err := handler.module.Get(ctx, orgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, organization)
+}
+
+func (handler *handler) Update(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid org id"))
+		return
+	}
+
+	var req *types.Organization
+	err = json.NewDecoder(r.Body).Decode(&req)
+	if err != nil {
+		render.Error(rw, err)
+	}
+
+	req.ID = orgID
+	err = handler.module.Update(ctx, req)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusNoContent, nil)
+}

pkg/modules/organization/implorganization/module.go

@@ -0,0 +1,33 @@
+package implorganization
+
+import (
+	"context"
+
+	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type module struct {
+	store types.OrganizationStore
+}
+
+func NewModule(organizationStore types.OrganizationStore) organization.Module {
+	return &module{store: organizationStore}
+}
+
+func (module *module) Create(ctx context.Context, organization *types.Organization) error {
+	return module.store.Create(ctx, organization)
+}
+
+func (module *module) Get(ctx context.Context, id valuer.UUID) (*types.Organization, error) {
+	return module.store.Get(ctx, id)
+}
+
+func (module *module) GetAll(ctx context.Context) ([]*types.Organization, error) {
+	return module.store.GetAll(ctx)
+}
+
+func (module *module) Update(ctx context.Context, updatedOrganization *types.Organization) error {
+	return module.store.Update(ctx, updatedOrganization)
+}

pkg/modules/organization/implorganization/store.go

@@ -0,0 +1,94 @@
+package implorganization
+
+import (
+	"context"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type store struct {
+	sqlstore sqlstore.SQLStore
+}
+
+func NewStore(sqlstore sqlstore.SQLStore) types.OrganizationStore {
+	return &store{sqlstore: sqlstore}
+}
+
+func (store *store) Create(ctx context.Context, organization *types.Organization) error {
+	_, err := store.
+		sqlstore.
+		BunDB().
+		NewInsert().
+		Model(organization).
+		Exec(ctx)
+	if err != nil {
+		return store.sqlstore.WrapAlreadyExistsErrf(err, types.ErrOrganizationAlreadyExists, "organization with name: %s already exists", organization.Name)
+	}
+
+	return nil
+}
+
+func (store *store) Get(ctx context.Context, id valuer.UUID) (*types.Organization, error) {
+	organization := new(types.Organization)
+	err := store.
+		sqlstore.
+		BunDB().
+		NewSelect().
+		Model(organization).
+		Where("id = ?", id.StringValue()).
+		Scan(ctx)
+	if err != nil {
+		return nil, store.sqlstore.WrapNotFoundErrf(err, types.ErrOrganizationNotFound, "organization with id: %s does not exist", id.StringValue())
+	}
+
+	return organization, nil
+}
+
+func (store *store) GetAll(ctx context.Context) ([]*types.Organization, error) {
+	organizations := make([]*types.Organization, 0)
+	err := store.
+		sqlstore.
+		BunDB().
+		NewSelect().
+		Model(&organizations).
+		Scan(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return organizations, nil
+}
+
+func (store *store) Update(ctx context.Context, organization *types.Organization) error {
+	_, err := store.
+		sqlstore.
+		BunDB().
+		NewUpdate().
+		Model(organization).
+		Set("display_name = ?", organization.DisplayName).
+		Set("updated_at = ?", time.Now()).
+		Where("id = ?", organization.ID.StringValue()).
+		Exec(ctx)
+	if err != nil {
+		return store.sqlstore.WrapAlreadyExistsErrf(err, types.ErrOrganizationAlreadyExists, "organization already exists")
+	}
+	return nil
+}
+
+func (store *store) Delete(ctx context.Context, id valuer.UUID) error {
+	_, err := store.
+		sqlstore.
+		BunDB().
+		NewDelete().
+		Model(new(types.Organization)).
+		Where("id = ?", id.StringValue()).
+		Exec(ctx)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/modules/organization/organization.go

@@ -0,0 +1,31 @@
+package organization
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type Module interface {
+	// Create creates the given organization
+	Create(context.Context, *types.Organization) error
+
+	// Get gets the organization based on the given id
+	Get(context.Context, valuer.UUID) (*types.Organization, error)
+
+	// GetAll gets all the organizations
+	GetAll(context.Context) ([]*types.Organization, error)
+
+	// Update updates the given organization based on id present
+	Update(context.Context, *types.Organization) error
+}
+
+type Handler interface {
+	// Get gets the organization based on the id in claims
+	Get(http.ResponseWriter, *http.Request)
+
+	// Update updates the organization based on the id in claims
+	Update(http.ResponseWriter, *http.Request)
+}

pkg/modules/preference/api.go

@@ -1,149 +0,0 @@
-package preference
-
-import (
-	"encoding/json"
-	"net/http"
-
-	errorsV2 "github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/preferencetypes"
-	"github.com/gorilla/mux"
-)
-
-type API interface {
-	GetOrgPreference(http.ResponseWriter, *http.Request)
-	UpdateOrgPreference(http.ResponseWriter, *http.Request)
-	GetAllOrgPreferences(http.ResponseWriter, *http.Request)
-
-	GetUserPreference(http.ResponseWriter, *http.Request)
-	UpdateUserPreference(http.ResponseWriter, *http.Request)
-	GetAllUserPreferences(http.ResponseWriter, *http.Request)
-}
-
-type preferenceAPI struct {
-	usecase Usecase
-}
-
-func NewAPI(usecase Usecase) API {
-	return &preferenceAPI{usecase: usecase}
-}
-
-func (p *preferenceAPI) GetOrgPreference(rw http.ResponseWriter, r *http.Request) {
-	preferenceId := mux.Vars(r)["preferenceId"]
-	claims, ok := authtypes.ClaimsFromContext(r.Context())
-	if !ok {
-		render.Error(rw, errorsV2.Newf(errorsV2.TypeUnauthenticated, errorsV2.CodeUnauthenticated, "unauthenticated"))
-		return
-	}
-	preference, err := p.usecase.GetOrgPreference(
-		r.Context(), preferenceId, claims.OrgID,
-	)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, preference)
-}
-
-func (p *preferenceAPI) UpdateOrgPreference(rw http.ResponseWriter, r *http.Request) {
-	preferenceId := mux.Vars(r)["preferenceId"]
-	req := preferencetypes.UpdatablePreference{}
-	claims, ok := authtypes.ClaimsFromContext(r.Context())
-	if !ok {
-		render.Error(rw, errorsV2.Newf(errorsV2.TypeUnauthenticated, errorsV2.CodeUnauthenticated, "unauthenticated"))
-		return
-	}
-
-	err := json.NewDecoder(r.Body).Decode(&req)
-
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-	err = p.usecase.UpdateOrgPreference(r.Context(), preferenceId, req.PreferenceValue, claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-func (p *preferenceAPI) GetAllOrgPreferences(rw http.ResponseWriter, r *http.Request) {
-	claims, ok := authtypes.ClaimsFromContext(r.Context())
-	if !ok {
-		render.Error(rw, errorsV2.Newf(errorsV2.TypeUnauthenticated, errorsV2.CodeUnauthenticated, "unauthenticated"))
-		return
-	}
-	preferences, err := p.usecase.GetAllOrgPreferences(
-		r.Context(), claims.OrgID,
-	)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, preferences)
-}
-
-func (p *preferenceAPI) GetUserPreference(rw http.ResponseWriter, r *http.Request) {
-	preferenceId := mux.Vars(r)["preferenceId"]
-	claims, ok := authtypes.ClaimsFromContext(r.Context())
-	if !ok {
-		render.Error(rw, errorsV2.Newf(errorsV2.TypeUnauthenticated, errorsV2.CodeUnauthenticated, "unauthenticated"))
-		return
-	}
-
-	preference, err := p.usecase.GetUserPreference(
-		r.Context(), preferenceId, claims.OrgID, claims.UserID,
-	)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, preference)
-}
-
-func (p *preferenceAPI) UpdateUserPreference(rw http.ResponseWriter, r *http.Request) {
-	preferenceId := mux.Vars(r)["preferenceId"]
-	claims, ok := authtypes.ClaimsFromContext(r.Context())
-	if !ok {
-		render.Error(rw, errorsV2.Newf(errorsV2.TypeUnauthenticated, errorsV2.CodeUnauthenticated, "unauthenticated"))
-		return
-	}
-	req := preferencetypes.UpdatablePreference{}
-
-	err := json.NewDecoder(r.Body).Decode(&req)
-
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-	err = p.usecase.UpdateUserPreference(r.Context(), preferenceId, req.PreferenceValue, claims.UserID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-func (p *preferenceAPI) GetAllUserPreferences(rw http.ResponseWriter, r *http.Request) {
-	claims, ok := authtypes.ClaimsFromContext(r.Context())
-	if !ok {
-		render.Error(rw, errorsV2.Newf(errorsV2.TypeUnauthenticated, errorsV2.CodeUnauthenticated, "unauthenticated"))
-		return
-	}
-	preferences, err := p.usecase.GetAllUserPreferences(
-		r.Context(), claims.OrgID, claims.UserID,
-	)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, preferences)
-}

pkg/modules/preference/implpreference/handler.go

@@ -0,0 +1,176 @@
+package implpreference
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/SigNoz/signoz/pkg/modules/preference"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/preferencetypes"
+	"github.com/gorilla/mux"
+)
+
+type handler struct {
+	module preference.Module
+}
+
+func NewHandler(module preference.Module) preference.Handler {
+	return &handler{module: module}
+}
+
+func (handler *handler) GetOrg(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	id, ok := mux.Vars(r)["preferenceId"]
+	if !ok {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is required"))
+		return
+	}
+
+	preference, err := handler.module.GetOrg(ctx, id, claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, preference)
+}
+
+func (handler *handler) UpdateOrg(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	id, ok := mux.Vars(r)["preferenceId"]
+	if !ok {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is required"))
+		return
+	}
+
+	req := new(preferencetypes.UpdatablePreference)
+
+	err = json.NewDecoder(r.Body).Decode(req)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	err = handler.module.UpdateOrg(ctx, id, req.PreferenceValue, claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusNoContent, nil)
+}
+
+func (handler *handler) GetAllOrg(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	preferences, err := handler.module.GetAllOrg(ctx, claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, preferences)
+}
+
+func (handler *handler) GetUser(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	id, ok := mux.Vars(r)["preferenceId"]
+	if !ok {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is required"))
+		return
+	}
+
+	preference, err := handler.module.GetUser(ctx, id, claims.OrgID, claims.UserID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, preference)
+}
+
+func (handler *handler) UpdateUser(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	id, ok := mux.Vars(r)["preferenceId"]
+	if !ok {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is required"))
+		return
+	}
+
+	req := new(preferencetypes.UpdatablePreference)
+	err = json.NewDecoder(r.Body).Decode(req)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	err = handler.module.UpdateUser(ctx, id, req.PreferenceValue, claims.UserID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusNoContent, nil)
+}
+
+func (handler *handler) GetAllUser(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	preferences, err := handler.module.GetAllUser(ctx, claims.OrgID, claims.UserID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, preferences)
+}

pkg/modules/preference/implpreference/module.go

@@ -1,10 +1,9 @@
-package core
+package implpreference
 
 import (
 	"context"
 	"database/sql"
 	"encoding/json"
-	"fmt"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
@@ -12,27 +11,28 @@ import (
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
-type usecase struct {
-	store      preferencetypes.PreferenceStore
+// Do not take inspiration from this code, it is a work in progress. See Organization module for a better implementation.
+type module struct {
+	store      preferencetypes.Store
 	defaultMap map[string]preferencetypes.Preference
 }
 
-func NewPreference(store preferencetypes.PreferenceStore, defaultMap map[string]preferencetypes.Preference) preference.Usecase {
-	return &usecase{store: store, defaultMap: defaultMap}
+func NewModule(store preferencetypes.Store, defaultMap map[string]preferencetypes.Preference) preference.Module {
+	return &module{store: store, defaultMap: defaultMap}
 }
 
-func (usecase *usecase) GetOrgPreference(ctx context.Context, preferenceID string, orgID string) (*preferencetypes.GettablePreference, error) {
-	preference, seen := usecase.defaultMap[preferenceID]
+func (module *module) GetOrg(ctx context.Context, preferenceID string, orgID string) (*preferencetypes.GettablePreference, error) {
+	preference, seen := module.defaultMap[preferenceID]
 	if !seen {
-		return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, fmt.Sprintf("no such preferenceID exists: %s", preferenceID))
+		return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "cannot find preference with id: %s", preferenceID)
 	}
 
-	isPreferenceEnabled := preference.IsEnabledForScope(preferencetypes.OrgAllowedScope)
-	if !isPreferenceEnabled {
-		return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, fmt.Sprintf("preference is not enabled at org scope: %s", preferenceID))
+	isEnabled := preference.IsEnabledForScope(preferencetypes.OrgAllowedScope)
+	if !isEnabled {
+		return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "preference is not enabled at org scope: %s", preferenceID)
 	}
 
-	orgPreference, err := usecase.store.GetOrgPreference(ctx, orgID, preferenceID)
+	org, err := module.store.GetOrg(ctx, orgID, preferenceID)
 	if err != nil {
 		if err == sql.ErrNoRows {
 			return &preferencetypes.GettablePreference{
@@ -40,24 +40,24 @@ func (usecase *usecase) GetOrgPreference(ctx context.Context, preferenceID strin
 				PreferenceValue: preference.DefaultValue,
 			}, nil
 		}
-		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, fmt.Sprintf("error in fetching the org preference: %s", preferenceID))
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error in fetching the org preference: %s", preferenceID)
 	}
 
 	return &preferencetypes.GettablePreference{
 		PreferenceID:    preferenceID,
-		PreferenceValue: preference.SanitizeValue(orgPreference.PreferenceValue),
+		PreferenceValue: preference.SanitizeValue(org.PreferenceValue),
 	}, nil
 }
 
-func (usecase *usecase) UpdateOrgPreference(ctx context.Context, preferenceID string, preferenceValue interface{}, orgID string) error {
-	preference, seen := usecase.defaultMap[preferenceID]
+func (module *module) UpdateOrg(ctx context.Context, preferenceID string, preferenceValue interface{}, orgID string) error {
+	preference, seen := module.defaultMap[preferenceID]
 	if !seen {
-		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, fmt.Sprintf("no such preferenceID exists: %s", preferenceID))
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "cannot find preference with id: %s", preferenceID)
 	}
 
-	isPreferenceEnabled := preference.IsEnabledForScope(preferencetypes.OrgAllowedScope)
-	if !isPreferenceEnabled {
-		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, fmt.Sprintf("preference is not enabled at org scope: %s", preferenceID))
+	isEnabled := preference.IsEnabledForScope(preferencetypes.OrgAllowedScope)
+	if !isEnabled {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "preference is not enabled at org scope: %s", preferenceID)
 	}
 
 	err := preference.IsValidValue(preferenceValue)
@@ -65,26 +65,26 @@ func (usecase *usecase) UpdateOrgPreference(ctx context.Context, preferenceID st
 		return err
 	}
 
-	storablePreferenceValue, encodeErr := json.Marshal(preferenceValue)
+	storableValue, encodeErr := json.Marshal(preferenceValue)
 	if encodeErr != nil {
 		return errors.Wrapf(encodeErr, errors.TypeInvalidInput, errors.CodeInvalidInput, "error in encoding the preference value")
 	}
 
-	orgPreference, dberr := usecase.store.GetOrgPreference(ctx, orgID, preferenceID)
+	org, dberr := module.store.GetOrg(ctx, orgID, preferenceID)
 	if dberr != nil && dberr != sql.ErrNoRows {
 		return errors.Wrapf(dberr, errors.TypeInternal, errors.CodeInternal, "error in getting the preference value")
 	}
 
 	if dberr != nil {
-		orgPreference.ID = valuer.GenerateUUID()
-		orgPreference.PreferenceID = preferenceID
-		orgPreference.PreferenceValue = string(storablePreferenceValue)
-		orgPreference.OrgID = orgID
+		org.ID = valuer.GenerateUUID()
+		org.PreferenceID = preferenceID
+		org.PreferenceValue = string(storableValue)
+		org.OrgID = orgID
 	} else {
-		orgPreference.PreferenceValue = string(storablePreferenceValue)
+		org.PreferenceValue = string(storableValue)
 	}
 
-	dberr = usecase.store.UpsertOrgPreference(ctx, orgPreference)
+	dberr = module.store.UpsertOrg(ctx, org)
 	if dberr != nil {
 		return errors.Wrapf(dberr, errors.TypeInternal, errors.CodeInternal, "error in setting the preference value")
 	}
@@ -92,19 +92,19 @@ func (usecase *usecase) UpdateOrgPreference(ctx context.Context, preferenceID st
 	return nil
 }
 
-func (usecase *usecase) GetAllOrgPreferences(ctx context.Context, orgID string) ([]*preferencetypes.PreferenceWithValue, error) {
-	allOrgPreferences := []*preferencetypes.PreferenceWithValue{}
-	orgPreferences, err := usecase.store.GetAllOrgPreferences(ctx, orgID)
+func (module *module) GetAllOrg(ctx context.Context, orgID string) ([]*preferencetypes.PreferenceWithValue, error) {
+	allOrgs := []*preferencetypes.PreferenceWithValue{}
+	orgs, err := module.store.GetAllOrg(ctx, orgID)
 	if err != nil {
 		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error in setting all org preference values")
 	}
 
 	preferenceValueMap := map[string]interface{}{}
-	for _, preferenceValue := range orgPreferences {
+	for _, preferenceValue := range orgs {
 		preferenceValueMap[preferenceValue.PreferenceID] = preferenceValue.PreferenceValue
 	}
 
-	for _, preference := range usecase.defaultMap {
+	for _, preference := range module.defaultMap {
 		isEnabledForOrgScope := preference.IsEnabledForScope(preferencetypes.OrgAllowedScope)
 		if isEnabledForOrgScope {
 			preferenceWithValue := &preferencetypes.PreferenceWithValue{}
@@ -126,16 +126,16 @@ func (usecase *usecase) GetAllOrgPreferences(ctx context.Context, orgID string)
 			}
 
 			preferenceWithValue.Value = preference.SanitizeValue(preferenceWithValue.Value)
-			allOrgPreferences = append(allOrgPreferences, preferenceWithValue)
+			allOrgs = append(allOrgs, preferenceWithValue)
 		}
 	}
-	return allOrgPreferences, nil
+	return allOrgs, nil
 }
 
-func (usecase *usecase) GetUserPreference(ctx context.Context, preferenceID string, orgID string, userID string) (*preferencetypes.GettablePreference, error) {
-	preference, seen := usecase.defaultMap[preferenceID]
+func (module *module) GetUser(ctx context.Context, preferenceID string, orgID string, userID string) (*preferencetypes.GettablePreference, error) {
+	preference, seen := module.defaultMap[preferenceID]
 	if !seen {
-		return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, fmt.Sprintf("no such preferenceID exists: %s", preferenceID))
+		return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "cannot find preference with id: %s", preferenceID)
 	}
 
 	preferenceValue := preferencetypes.GettablePreference{
@@ -143,29 +143,29 @@ func (usecase *usecase) GetUserPreference(ctx context.Context, preferenceID stri
 		PreferenceValue: preference.DefaultValue,
 	}
 
-	isPreferenceEnabledAtUserScope := preference.IsEnabledForScope(preferencetypes.UserAllowedScope)
-	if !isPreferenceEnabledAtUserScope {
-		return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, fmt.Sprintf("preference is not enabled at user scope: %s", preferenceID))
+	isEnabledAtUserScope := preference.IsEnabledForScope(preferencetypes.UserAllowedScope)
+	if !isEnabledAtUserScope {
+		return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "preference is not enabled at user scope: %s", preferenceID)
 	}
 
-	isPreferenceEnabledAtOrgScope := preference.IsEnabledForScope(preferencetypes.OrgAllowedScope)
-	if isPreferenceEnabledAtOrgScope {
-		orgPreference, err := usecase.store.GetOrgPreference(ctx, orgID, preferenceID)
+	isEnabledAtOrgScope := preference.IsEnabledForScope(preferencetypes.OrgAllowedScope)
+	if isEnabledAtOrgScope {
+		org, err := module.store.GetOrg(ctx, orgID, preferenceID)
 		if err != nil && err != sql.ErrNoRows {
-			return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, fmt.Sprintf("error in fetching the org preference: %s", preferenceID))
+			return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error in fetching the org preference: %s", preferenceID)
 		}
 		if err == nil {
-			preferenceValue.PreferenceValue = orgPreference.PreferenceValue
+			preferenceValue.PreferenceValue = org.PreferenceValue
 		}
 	}
 
-	userPreference, err := usecase.store.GetUserPreference(ctx, userID, preferenceID)
+	user, err := module.store.GetUser(ctx, userID, preferenceID)
 	if err != nil && err != sql.ErrNoRows {
-		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, fmt.Sprintf("error in fetching the user preference: %s", preferenceID))
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error in fetching the user preference: %s", preferenceID)
 	}
 
 	if err == nil {
-		preferenceValue.PreferenceValue = userPreference.PreferenceValue
+		preferenceValue.PreferenceValue = user.PreferenceValue
 	}
 
 	return &preferencetypes.GettablePreference{
@@ -174,15 +174,15 @@ func (usecase *usecase) GetUserPreference(ctx context.Context, preferenceID stri
 	}, nil
 }
 
-func (usecase *usecase) UpdateUserPreference(ctx context.Context, preferenceID string, preferenceValue interface{}, userID string) error {
-	preference, seen := usecase.defaultMap[preferenceID]
+func (module *module) UpdateUser(ctx context.Context, preferenceID string, preferenceValue interface{}, userID string) error {
+	preference, seen := module.defaultMap[preferenceID]
 	if !seen {
-		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, fmt.Sprintf("no such preferenceID exists: %s", preferenceID))
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "cannot find preference with id: %s", preferenceID)
 	}
 
-	isPreferenceEnabledAtUserScope := preference.IsEnabledForScope(preferencetypes.UserAllowedScope)
-	if !isPreferenceEnabledAtUserScope {
-		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, fmt.Sprintf("preference is not enabled at user scope: %s", preferenceID))
+	isEnabledAtUserScope := preference.IsEnabledForScope(preferencetypes.UserAllowedScope)
+	if !isEnabledAtUserScope {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "preference is not enabled at user scope: %s", preferenceID)
 	}
 
 	err := preference.IsValidValue(preferenceValue)
@@ -190,26 +190,26 @@ func (usecase *usecase) UpdateUserPreference(ctx context.Context, preferenceID s
 		return err
 	}
 
-	storablePreferenceValue, encodeErr := json.Marshal(preferenceValue)
+	storableValue, encodeErr := json.Marshal(preferenceValue)
 	if encodeErr != nil {
 		return errors.Wrapf(encodeErr, errors.TypeInvalidInput, errors.CodeInvalidInput, "error in encoding the preference value")
 	}
 
-	userPreference, dberr := usecase.store.GetUserPreference(ctx, userID, preferenceID)
+	user, dberr := module.store.GetUser(ctx, userID, preferenceID)
 	if dberr != nil && dberr != sql.ErrNoRows {
 		return errors.Wrapf(dberr, errors.TypeInternal, errors.CodeInternal, "error in getting the preference value")
 	}
 
 	if dberr != nil {
-		userPreference.ID = valuer.GenerateUUID()
-		userPreference.PreferenceID = preferenceID
-		userPreference.PreferenceValue = string(storablePreferenceValue)
-		userPreference.UserID = userID
+		user.ID = valuer.GenerateUUID()
+		user.PreferenceID = preferenceID
+		user.PreferenceValue = string(storableValue)
+		user.UserID = userID
 	} else {
-		userPreference.PreferenceValue = string(storablePreferenceValue)
+		user.PreferenceValue = string(storableValue)
 	}
 
-	dberr = usecase.store.UpsertUserPreference(ctx, userPreference)
+	dberr = module.store.UpsertUser(ctx, user)
 	if dberr != nil {
 		return errors.Wrapf(dberr, errors.TypeInternal, errors.CodeInternal, "error in setting the preference value")
 	}
@@ -217,30 +217,30 @@ func (usecase *usecase) UpdateUserPreference(ctx context.Context, preferenceID s
 	return nil
 }
 
-func (usecase *usecase) GetAllUserPreferences(ctx context.Context, orgID string, userID string) ([]*preferencetypes.PreferenceWithValue, error) {
-	allUserPreferences := []*preferencetypes.PreferenceWithValue{}
+func (module *module) GetAllUser(ctx context.Context, orgID string, userID string) ([]*preferencetypes.PreferenceWithValue, error) {
+	allUsers := []*preferencetypes.PreferenceWithValue{}
 
-	orgPreferences, err := usecase.store.GetAllOrgPreferences(ctx, orgID)
+	orgs, err := module.store.GetAllOrg(ctx, orgID)
 	if err != nil {
 		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error in setting all org preference values")
 	}
 
 	preferenceOrgValueMap := map[string]interface{}{}
-	for _, preferenceValue := range orgPreferences {
+	for _, preferenceValue := range orgs {
 		preferenceOrgValueMap[preferenceValue.PreferenceID] = preferenceValue.PreferenceValue
 	}
 
-	userPreferences, err := usecase.store.GetAllUserPreferences(ctx, userID)
+	users, err := module.store.GetAllUser(ctx, userID)
 	if err != nil {
 		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "error in setting all user preference values")
 	}
 
 	preferenceUserValueMap := map[string]interface{}{}
-	for _, preferenceValue := range userPreferences {
+	for _, preferenceValue := range users {
 		preferenceUserValueMap[preferenceValue.PreferenceID] = preferenceValue.PreferenceValue
 	}
 
-	for _, preference := range usecase.defaultMap {
+	for _, preference := range module.defaultMap {
 		isEnabledForUserScope := preference.IsEnabledForScope(preferencetypes.UserAllowedScope)
 
 		if isEnabledForUserScope {
@@ -271,8 +271,8 @@ func (usecase *usecase) GetAllUserPreferences(ctx context.Context, orgID string,
 			}
 
 			preferenceWithValue.Value = preference.SanitizeValue(preferenceWithValue.Value)
-			allUserPreferences = append(allUserPreferences, preferenceWithValue)
+			allUsers = append(allUsers, preferenceWithValue)
 		}
 	}
-	return allUserPreferences, nil
+	return allUsers, nil
 }

pkg/modules/preference/implpreference/store.go

@@ -1,4 +1,4 @@
-package core
+package implpreference
 
 import (
 	"context"
@@ -11,11 +11,11 @@ type store struct {
 	store sqlstore.SQLStore
 }
 
-func NewStore(db sqlstore.SQLStore) preferencetypes.PreferenceStore {
+func NewStore(db sqlstore.SQLStore) preferencetypes.Store {
 	return &store{store: db}
 }
 
-func (store *store) GetOrgPreference(ctx context.Context, orgID string, preferenceID string) (*preferencetypes.StorableOrgPreference, error) {
+func (store *store) GetOrg(ctx context.Context, orgID string, preferenceID string) (*preferencetypes.StorableOrgPreference, error) {
 	orgPreference := new(preferencetypes.StorableOrgPreference)
 	err := store.
 		store.
@@ -33,7 +33,7 @@ func (store *store) GetOrgPreference(ctx context.Context, orgID string, preferen
 	return orgPreference, nil
 }
 
-func (store *store) GetAllOrgPreferences(ctx context.Context, orgID string) ([]*preferencetypes.StorableOrgPreference, error) {
+func (store *store) GetAllOrg(ctx context.Context, orgID string) ([]*preferencetypes.StorableOrgPreference, error) {
 	orgPreferences := make([]*preferencetypes.StorableOrgPreference, 0)
 	err := store.
 		store.
@@ -50,7 +50,7 @@ func (store *store) GetAllOrgPreferences(ctx context.Context, orgID string) ([]*
 	return orgPreferences, nil
 }
 
-func (store *store) UpsertOrgPreference(ctx context.Context, orgPreference *preferencetypes.StorableOrgPreference) error {
+func (store *store) UpsertOrg(ctx context.Context, orgPreference *preferencetypes.StorableOrgPreference) error {
 	_, err := store.
 		store.
 		BunDB().
@@ -65,7 +65,7 @@ func (store *store) UpsertOrgPreference(ctx context.Context, orgPreference *pref
 	return nil
 }
 
-func (store *store) GetUserPreference(ctx context.Context, userID string, preferenceID string) (*preferencetypes.StorableUserPreference, error) {
+func (store *store) GetUser(ctx context.Context, userID string, preferenceID string) (*preferencetypes.StorableUserPreference, error) {
 	userPreference := new(preferencetypes.StorableUserPreference)
 	err := store.
 		store.
@@ -83,7 +83,7 @@ func (store *store) GetUserPreference(ctx context.Context, userID string, prefer
 	return userPreference, nil
 }
 
-func (store *store) GetAllUserPreferences(ctx context.Context, userID string) ([]*preferencetypes.StorableUserPreference, error) {
+func (store *store) GetAllUser(ctx context.Context, userID string) ([]*preferencetypes.StorableUserPreference, error) {
 	userPreferences := make([]*preferencetypes.StorableUserPreference, 0)
 	err := store.
 		store.
@@ -100,7 +100,7 @@ func (store *store) GetAllUserPreferences(ctx context.Context, userID string) ([
 	return userPreferences, nil
 }
 
-func (store *store) UpsertUserPreference(ctx context.Context, userPreference *preferencetypes.StorableUserPreference) error {
+func (store *store) UpsertUser(ctx context.Context, userPreference *preferencetypes.StorableUserPreference) error {
 	_, err := store.
 		store.
 		BunDB().

pkg/modules/preference/preference.go

@@ -0,0 +1,48 @@
+package preference
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/types/preferencetypes"
+)
+
+type Module interface {
+	// Returns the preference for the given organization
+	GetOrg(ctx context.Context, preferenceId string, orgId string) (*preferencetypes.GettablePreference, error)
+
+	// Returns the preference for the given user
+	GetUser(ctx context.Context, preferenceId string, orgId string, userId string) (*preferencetypes.GettablePreference, error)
+
+	// Returns all preferences for the given organization
+	GetAllOrg(ctx context.Context, orgId string) ([]*preferencetypes.PreferenceWithValue, error)
+
+	// Returns all preferences for the given user
+	GetAllUser(ctx context.Context, orgId string, userId string) ([]*preferencetypes.PreferenceWithValue, error)
+
+	// Updates the preference for the given organization
+	UpdateOrg(ctx context.Context, preferenceId string, preferenceValue interface{}, orgId string) error
+
+	// Updates the preference for the given user
+	UpdateUser(ctx context.Context, preferenceId string, preferenceValue interface{}, userId string) error
+}
+
+type Handler interface {
+	// Returns the preference for the given organization
+	GetOrg(http.ResponseWriter, *http.Request)
+
+	// Updates the preference for the given organization
+	UpdateOrg(http.ResponseWriter, *http.Request)
+
+	// Returns all preferences for the given organization
+	GetAllOrg(http.ResponseWriter, *http.Request)
+
+	// Returns the preference for the given user
+	GetUser(http.ResponseWriter, *http.Request)
+
+	// Updates the preference for the given user
+	UpdateUser(http.ResponseWriter, *http.Request)
+
+	// Returns all preferences for the given user
+	GetAllUser(http.ResponseWriter, *http.Request)
+}

pkg/modules/preference/usecase.go

@@ -1,17 +0,0 @@
-package preference
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/types/preferencetypes"
-)
-
-type Usecase interface {
-	GetOrgPreference(ctx context.Context, preferenceId string, orgId string) (*preferencetypes.GettablePreference, error)
-	UpdateOrgPreference(ctx context.Context, preferenceId string, preferenceValue interface{}, orgId string) error
-	GetAllOrgPreferences(ctx context.Context, orgId string) ([]*preferencetypes.PreferenceWithValue, error)
-
-	GetUserPreference(ctx context.Context, preferenceId string, orgId string, userId string) (*preferencetypes.GettablePreference, error)
-	UpdateUserPreference(ctx context.Context, preferenceId string, preferenceValue interface{}, userId string) error
-	GetAllUserPreferences(ctx context.Context, orgId string, userId string) ([]*preferencetypes.PreferenceWithValue, error)
-}

pkg/query-service/app/apdex.go

@@ -1,19 +1,19 @@
 package app
 
 import (
-	"errors"
 	"net/http"
 	"strings"
 
+	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/query-service/dao"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 )
 
 func (aH *APIHandler) setApdexSettings(w http.ResponseWriter, r *http.Request) {
-	claims, ok := authtypes.ClaimsFromContext(r.Context())
-	if !ok {
-		RespondError(w, &model.ApiError{Err: errors.New("unauthorized"), Typ: model.ErrorUnauthorized}, nil)
+	claims, errv2 := authtypes.ClaimsFromContext(r.Context())
+	if errv2 != nil {
+		render.Error(w, errv2)
 		return
 	}
 	req, err := parseSetApdexScoreRequest(r)
@@ -31,9 +31,9 @@ func (aH *APIHandler) setApdexSettings(w http.ResponseWriter, r *http.Request) {
 
 func (aH *APIHandler) getApdexSettings(w http.ResponseWriter, r *http.Request) {
 	services := r.URL.Query().Get("services")
-	claims, ok := authtypes.ClaimsFromContext(r.Context())
-	if !ok {
-		RespondError(w, &model.ApiError{Err: errors.New("unauthorized"), Typ: model.ErrorUnauthorized}, nil)
+	claims, errv2 := authtypes.ClaimsFromContext(r.Context())
+	if errv2 != nil {
+		render.Error(w, errv2)
 		return
 	}
 	apdexSet, err := dao.DB().GetApdexSettings(r.Context(), claims.OrgID, strings.Split(strings.TrimSpace(services), ","))

pkg/query-service/app/auth.go

@@ -1,123 +0,0 @@
-package app
-
-import (
-	"context"
-	"errors"
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/query-service/auth"
-	"github.com/SigNoz/signoz/pkg/query-service/constants"
-	"github.com/SigNoz/signoz/pkg/query-service/model"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/gorilla/mux"
-)
-
-type AuthMiddleware struct {
-	GetUserFromRequest func(r context.Context) (*types.GettableUser, error)
-}
-
-func NewAuthMiddleware(f func(ctx context.Context) (*types.GettableUser, error)) *AuthMiddleware {
-	return &AuthMiddleware{
-		GetUserFromRequest: f,
-	}
-}
-
-func (am *AuthMiddleware) OpenAccess(f func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		f(w, r)
-	}
-}
-
-func (am *AuthMiddleware) ViewAccess(f func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		user, err := am.GetUserFromRequest(r.Context())
-		if err != nil {
-			RespondError(w, &model.ApiError{
-				Typ: model.ErrorUnauthorized,
-				Err: err,
-			}, nil)
-			return
-		}
-
-		if !(auth.IsViewer(user) || auth.IsEditor(user) || auth.IsAdmin(user)) {
-			RespondError(w, &model.ApiError{
-				Typ: model.ErrorForbidden,
-				Err: errors.New("API is accessible to viewers/editors/admins"),
-			}, nil)
-			return
-		}
-		ctx := context.WithValue(r.Context(), constants.ContextUserKey, user)
-		r = r.WithContext(ctx)
-		f(w, r)
-	}
-}
-
-func (am *AuthMiddleware) EditAccess(f func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		user, err := am.GetUserFromRequest(r.Context())
-		if err != nil {
-			RespondError(w, &model.ApiError{
-				Typ: model.ErrorUnauthorized,
-				Err: err,
-			}, nil)
-			return
-		}
-		if !(auth.IsEditor(user) || auth.IsAdmin(user)) {
-			RespondError(w, &model.ApiError{
-				Typ: model.ErrorForbidden,
-				Err: errors.New("API is accessible to editors/admins"),
-			}, nil)
-			return
-		}
-		ctx := context.WithValue(r.Context(), constants.ContextUserKey, user)
-		r = r.WithContext(ctx)
-		f(w, r)
-	}
-}
-
-func (am *AuthMiddleware) SelfAccess(f func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		user, err := am.GetUserFromRequest(r.Context())
-		if err != nil {
-			RespondError(w, &model.ApiError{
-				Typ: model.ErrorUnauthorized,
-				Err: err,
-			}, nil)
-			return
-		}
-		id := mux.Vars(r)["id"]
-		if !(auth.IsSelfAccessRequest(user, id) || auth.IsAdmin(user)) {
-			RespondError(w, &model.ApiError{
-				Typ: model.ErrorForbidden,
-				Err: errors.New("API is accessible for self access or to the admins"),
-			}, nil)
-			return
-		}
-		ctx := context.WithValue(r.Context(), constants.ContextUserKey, user)
-		r = r.WithContext(ctx)
-		f(w, r)
-	}
-}
-
-func (am *AuthMiddleware) AdminAccess(f func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		user, err := am.GetUserFromRequest(r.Context())
-		if err != nil {
-			RespondError(w, &model.ApiError{
-				Typ: model.ErrorUnauthorized,
-				Err: err,
-			}, nil)
-			return
-		}
-		if !auth.IsAdmin(user) {
-			RespondError(w, &model.ApiError{
-				Typ: model.ErrorForbidden,
-				Err: errors.New("API is accessible to admins only"),
-			}, nil)
-			return
-		}
-		ctx := context.WithValue(r.Context(), constants.ContextUserKey, user)
-		r = r.WithContext(ctx)
-		f(w, r)
-	}
-}

pkg/query-service/app/clickhouseReader/options.go

@@ -17,8 +17,6 @@ const (
 
 const (
 	defaultTraceDB                 string        = "signoz_traces"
-	defaultOperationsTable         string        = "distributed_signoz_operations"
-	defaultIndexTable              string        = "distributed_signoz_index_v2"
 	defaultLocalIndexTable         string        = "signoz_index_v2"
 	defaultErrorTable              string        = "distributed_signoz_error_index_v2"
 	defaultDurationTable           string        = "distributed_durationSort"
@@ -59,19 +57,10 @@ type namespaceConfig struct {
 	Enabled                 bool
 	Datasource              string
 	TraceDB                 string
-	OperationsTable         string
-	IndexTable              string
-	LocalIndexTable         string
-	DurationTable           string
-	UsageExplorerTable      string
-	SpansTable              string
 	ErrorTable              string
+	LocalIndexTable         string
 	SpanAttributeTableV2    string
 	SpanAttributeKeysTable  string
-	DependencyGraphTable    string
-	TopLevelOperationsTable string
-	LogsDB                  string
-	LogsTable               string
 	LogsLocalTable          string
 	LogsAttributeKeysTable  string
 	LogsResourceKeysTable   string
@@ -82,6 +71,7 @@ type namespaceConfig struct {
 	Encoding                Encoding
 	Connector               Connector
 
+	LogsDB                   string
 	LogsLocalTableV2         string
 	LogsTableV2              string
 	LogsResourceLocalTableV2 string

pkg/query-service/app/cloudintegrations/controller_test.go

@@ -4,12 +4,13 @@ import (
 	"context"
 	"testing"
 
-	"github.com/SigNoz/signoz/pkg/query-service/auth"
-	"github.com/SigNoz/signoz/pkg/query-service/constants"
+	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/modules/organization/implorganization"
 	"github.com/SigNoz/signoz/pkg/query-service/dao"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 	"github.com/SigNoz/signoz/pkg/query-service/utils"
 	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/require"
 )
@@ -20,7 +21,8 @@ func TestRegenerateConnectionUrlWithUpdatedConfig(t *testing.T) {
 	controller, err := NewController(sqlStore)
 	require.NoError(err)
 
-	user, apiErr := createTestUser()
+	organizationModule := implorganization.NewModule(implorganization.NewStore(sqlStore))
+	user, apiErr := createTestUser(organizationModule)
 	require.Nil(apiErr)
 
 	// should be able to generate connection url for
@@ -66,8 +68,8 @@ func TestAgentCheckIns(t *testing.T) {
 	sqlStore := utils.NewQueryServiceDBForTests(t)
 	controller, err := NewController(sqlStore)
 	require.NoError(err)
-
-	user, apiErr := createTestUser()
+	organizationModule := implorganization.NewModule(implorganization.NewStore(sqlStore))
+	user, apiErr := createTestUser(organizationModule)
 	require.Nil(apiErr)
 
 	// An agent should be able to check in from a cloud account even
@@ -118,7 +120,7 @@ func TestAgentCheckIns(t *testing.T) {
 
 	// After disconnecting existing account record, the agent should be able to
 	// connected for a particular cloud account id
-	_, apiErr = controller.DisconnectAccount(
+	_, _ = controller.DisconnectAccount(
 		context.TODO(), user.OrgID, "aws", testAccountId1,
 	)
 
@@ -153,7 +155,8 @@ func TestCantDisconnectNonExistentAccount(t *testing.T) {
 	controller, err := NewController(sqlStore)
 	require.NoError(err)
 
-	user, apiErr := createTestUser()
+	organizationModule := implorganization.NewModule(implorganization.NewStore(sqlStore))
+	user, apiErr := createTestUser(organizationModule)
 	require.Nil(apiErr)
 
 	// Attempting to disconnect a non-existent account should return error
@@ -171,7 +174,8 @@ func TestConfigureService(t *testing.T) {
 	controller, err := NewController(sqlStore)
 	require.NoError(err)
 
-	user, apiErr := createTestUser()
+	organizationModule := implorganization.NewModule(implorganization.NewStore(sqlStore))
+	user, apiErr := createTestUser(organizationModule)
 	require.Nil(apiErr)
 
 	// create a connected account
@@ -286,23 +290,15 @@ func makeTestConnectedAccount(t *testing.T, orgId string, controller *Controller
 	return acc
 }
 
-func createTestUser() (*types.User, *model.ApiError) {
+func createTestUser(organizationModule organization.Module) (*types.User, *model.ApiError) {
 	// Create a test user for auth
 	ctx := context.Background()
-	org, apiErr := dao.DB().CreateOrg(ctx, &types.Organization{
-		Name: "test",
-	})
-	if apiErr != nil {
-		return nil, apiErr
+	organization := types.NewOrganization("test")
+	err := organizationModule.Create(ctx, organization)
+	if err != nil {
+		return nil, model.InternalError(err)
 	}
 
-	group, apiErr := dao.DB().GetGroupByName(ctx, constants.AdminGroup)
-	if apiErr != nil {
-		return nil, apiErr
-	}
-
-	auth.InitAuthCache(ctx)
-
 	userId := uuid.NewString()
 	return dao.DB().CreateUser(
 		ctx,
@@ -311,8 +307,8 @@ func createTestUser() (*types.User, *model.ApiError) {
 			Name:     "test",
 			Email:    userId[:8] + "test@test.com",
 			Password: "test",
-			OrgID:    org.ID,
-			GroupID:  group.ID,
+			OrgID:    organization.ID.StringValue(),
+			Role:     authtypes.RoleAdmin.String(),
 		},
 		true,
 	)

pkg/query-service/app/explorer/db.go

@@ -108,8 +108,8 @@ func CreateView(ctx context.Context, orgID string, view v3.SavedView) (valuer.UU
 	createdAt := time.Now()
 	updatedAt := time.Now()
 
-	claims, ok := authtypes.ClaimsFromContext(ctx)
-	if !ok {
+	claims, errv2 := authtypes.ClaimsFromContext(ctx)
+	if errv2 != nil {
 		return valuer.UUID{}, fmt.Errorf("error in getting email from context")
 	}
 
@@ -177,8 +177,8 @@ func UpdateView(ctx context.Context, orgID string, uuid valuer.UUID, view v3.Sav
 		return fmt.Errorf("error in marshalling explorer query data: %s", err.Error())
 	}
 
-	claims, ok := authtypes.ClaimsFromContext(ctx)
-	if !ok {
+	claims, errv2 := authtypes.ClaimsFromContext(ctx)
+	if errv2 != nil {
 		return fmt.Errorf("error in getting email from context")
 	}
 

pkg/query-service/app/integrations/manager_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"testing"
 
+	"github.com/SigNoz/signoz/pkg/modules/organization/implorganization"
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/stretchr/testify/require"
 )
@@ -11,10 +12,11 @@ import (
 func TestIntegrationLifecycle(t *testing.T) {
 	require := require.New(t)
 
-	mgr := NewTestIntegrationsManager(t)
+	mgr, store := NewTestIntegrationsManager(t)
 	ctx := context.Background()
 
-	user, apiErr := createTestUser()
+	organizationModule := implorganization.NewModule(implorganization.NewStore(store))
+	user, apiErr := createTestUser(organizationModule)
 	if apiErr != nil {
 		t.Fatalf("could not create test user: %v", apiErr)
 	}

pkg/query-service/app/integrations/test_utils.go

@@ -5,19 +5,20 @@ import (
 	"slices"
 	"testing"
 
-	"github.com/SigNoz/signoz/pkg/query-service/auth"
-	"github.com/SigNoz/signoz/pkg/query-service/constants"
+	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/query-service/dao"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	"github.com/SigNoz/signoz/pkg/query-service/utils"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/types/pipelinetypes"
 	ruletypes "github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/google/uuid"
 )
 
-func NewTestIntegrationsManager(t *testing.T) *Manager {
+func NewTestIntegrationsManager(t *testing.T) (*Manager, sqlstore.SQLStore) {
 	testDB := utils.NewQueryServiceDBForTests(t)
 
 	installedIntegrationsRepo, err := NewInstalledIntegrationsSqliteRepo(testDB)
@@ -28,26 +29,18 @@ func NewTestIntegrationsManager(t *testing.T) *Manager {
 	return &Manager{
 		availableIntegrationsRepo: &TestAvailableIntegrationsRepo{},
 		installedIntegrationsRepo: installedIntegrationsRepo,
-	}
+	}, testDB
 }
 
-func createTestUser() (*types.User, *model.ApiError) {
+func createTestUser(organizationModule organization.Module) (*types.User, *model.ApiError) {
 	// Create a test user for auth
 	ctx := context.Background()
-	org, apiErr := dao.DB().CreateOrg(ctx, &types.Organization{
-		Name: "test",
-	})
-	if apiErr != nil {
-		return nil, apiErr
+	organization := types.NewOrganization("test")
+	err := organizationModule.Create(ctx, organization)
+	if err != nil {
+		return nil, model.InternalError(err)
 	}
 
-	group, apiErr := dao.DB().GetGroupByName(ctx, constants.AdminGroup)
-	if apiErr != nil {
-		return nil, apiErr
-	}
-
-	auth.InitAuthCache(ctx)
-
 	userId := uuid.NewString()
 	return dao.DB().CreateUser(
 		ctx,
@@ -56,8 +49,8 @@ func createTestUser() (*types.User, *model.ApiError) {
 			Name:     "test",
 			Email:    userId[:8] + "test@test.com",
 			Password: "test",
-			OrgID:    org.ID,
-			GroupID:  group.ID,
+			OrgID:    organization.ID.StringValue(),
+			Role:     authtypes.RoleAdmin.String(),
 		},
 		true,
 	)