feat: refactored the member status mapping

.github/workflows/integrationci.yaml

@@ -49,7 +49,6 @@ jobs:
           - ttl
           - alerts
           - ingestionkeys
-          - rootuser
         sqlstore-provider:
           - postgres
           - sqlite

conf/example.yaml

@@ -328,18 +328,15 @@ user:
 ##################### IdentN #####################
 identn:
   tokenizer:
-    # toggle tokenizer identN
+    # toggle the identN resolver
     enabled: true
     # headers to use for tokenizer identN resolver
     headers:
       - Authorization
       - Sec-WebSocket-Protocol
   apikey:
-    # toggle apikey identN
+    # toggle the identN resolver
     enabled: true
     # headers to use for apikey identN resolver
     headers:
       - SIGNOZ-API-KEY
-  impersonation:
-    # toggle impersonation identN, when enabled, all requests will impersonate the root user
-    enabled: false

docs/api/openapi.yml

@@ -598,39 +598,6 @@ components:
       required:
       - config
       type: object
-    GlobaltypesAPIKeyConfig:
-      properties:
-        enabled:
-          type: boolean
-      type: object
-    GlobaltypesConfig:
-      properties:
-        external_url:
-          type: string
-        identN:
-          $ref: '#/components/schemas/GlobaltypesIdentNConfig'
-        ingestion_url:
-          type: string
-      type: object
-    GlobaltypesIdentNConfig:
-      properties:
-        apikey:
-          $ref: '#/components/schemas/GlobaltypesAPIKeyConfig'
-        impersonation:
-          $ref: '#/components/schemas/GlobaltypesImpersonationConfig'
-        tokenizer:
-          $ref: '#/components/schemas/GlobaltypesTokenizerConfig'
-      type: object
-    GlobaltypesImpersonationConfig:
-      properties:
-        enabled:
-          type: boolean
-      type: object
-    GlobaltypesTokenizerConfig:
-      properties:
-        enabled:
-          type: boolean
-      type: object
     MetricsexplorertypesListMetric:
       properties:
         description:
@@ -2063,6 +2030,13 @@ components:
       required:
       - id
       type: object
+    TypesGettableGlobalConfig:
+      properties:
+        external_url:
+          type: string
+        ingestion_url:
+          type: string
+      type: object
     TypesIdentifiable:
       properties:
         id:
@@ -2127,17 +2101,6 @@ components:
         role:
           type: string
       type: object
-    TypesPostableAcceptInvite:
-      properties:
-        displayName:
-          type: string
-        password:
-          type: string
-        sourceUrl:
-          type: string
-        token:
-          type: string
-      type: object
     TypesPostableBulkInviteRequest:
       properties:
         invites:
@@ -3281,38 +3244,7 @@ paths:
               schema:
                 properties:
                   data:
-                    $ref: '#/components/schemas/GlobaltypesConfig'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      summary: Get global config
-      tags:
-      - global
-  /api/v1/invite:
-    get:
-      deprecated: false
-      description: This endpoint lists all invites
-      operationId: ListInvite
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    items:
-                      $ref: '#/components/schemas/TypesInvite'
-                    type: array
+                    $ref: '#/components/schemas/TypesGettableGlobalConfig'
                   status:
                     type: string
                 required:
@@ -3340,12 +3272,13 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - ADMIN
+        - EDITOR
       - tokenizer:
-        - ADMIN
-      summary: List invites
+        - EDITOR
+      summary: Get global config
       tags:
-      - users
+      - global
+  /api/v1/invite:
     post:
       deprecated: false
       description: This endpoint creates an invite for a user
@@ -3408,151 +3341,6 @@ paths:
       summary: Create invite
       tags:
       - users
-  /api/v1/invite/{id}:
-    delete:
-      deprecated: false
-      description: This endpoint deletes an invite by id
-      operationId: DeleteInvite
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "204":
-          description: No Content
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Delete invite
-      tags:
-      - users
-  /api/v1/invite/{token}:
-    get:
-      deprecated: false
-      description: This endpoint gets an invite by token
-      operationId: GetInvite
-      parameters:
-      - in: path
-        name: token
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/TypesInvite'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      summary: Get invite
-      tags:
-      - users
-  /api/v1/invite/accept:
-    post:
-      deprecated: false
-      description: This endpoint accepts an invite by token
-      operationId: AcceptInvite
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/TypesPostableAcceptInvite'
-      responses:
-        "201":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/TypesUser'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: Created
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      summary: Accept invite
-      tags:
-      - users
   /api/v1/invite/bulk:
     post:
       deprecated: false
@@ -5823,9 +5611,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - EDITOR
+        - ADMIN
       - tokenizer:
-        - EDITOR
+        - ADMIN
       summary: Get ingestion keys for workspace
       tags:
       - gateway
@@ -5873,9 +5661,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - EDITOR
+        - ADMIN
       - tokenizer:
-        - EDITOR
+        - ADMIN
       summary: Create ingestion key for workspace
       tags:
       - gateway
@@ -5913,9 +5701,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - EDITOR
+        - ADMIN
       - tokenizer:
-        - EDITOR
+        - ADMIN
       summary: Delete ingestion key for workspace
       tags:
       - gateway
@@ -5957,9 +5745,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - EDITOR
+        - ADMIN
       - tokenizer:
-        - EDITOR
+        - ADMIN
       summary: Update ingestion key for workspace
       tags:
       - gateway
@@ -6014,9 +5802,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - EDITOR
+        - ADMIN
       - tokenizer:
-        - EDITOR
+        - ADMIN
       summary: Create limit for the ingestion key
       tags:
       - gateway
@@ -6054,9 +5842,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - EDITOR
+        - ADMIN
       - tokenizer:
-        - EDITOR
+        - ADMIN
       summary: Delete limit for the ingestion key
       tags:
       - gateway
@@ -6098,9 +5886,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - EDITOR
+        - ADMIN
       - tokenizer:
-        - EDITOR
+        - ADMIN
       summary: Update limit for the ingestion key
       tags:
       - gateway
@@ -6158,9 +5946,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - EDITOR
+        - ADMIN
       - tokenizer:
-        - EDITOR
+        - ADMIN
       summary: Search ingestion keys for workspace
       tags:
       - gateway

ee/licensing/httplicensing/provider.go

@@ -198,10 +198,7 @@ func (provider *provider) Checkout(ctx context.Context, organizationID valuer.UU
 
 	response, err := provider.zeus.GetCheckoutURL(ctx, activeLicense.Key, body)
 	if err != nil {
-		if errors.Ast(err, errors.TypeAlreadyExists) {
-			return nil, errors.WithAdditionalf(err, "checkout has already been completed for this account. Please click 'Refresh Status' to sync your subscription")
-		}
-		return nil, err
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to generate checkout session")
 	}
 
 	return &licensetypes.GettableSubscription{RedirectURL: gjson.GetBytes(response, "url").String()}, nil
@@ -220,7 +217,7 @@ func (provider *provider) Portal(ctx context.Context, organizationID valuer.UUID
 
 	response, err := provider.zeus.GetPortalURL(ctx, activeLicense.Key, body)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to generate portal session")
 	}
 
 	return &licensetypes.GettableSubscription{RedirectURL: gjson.GetBytes(response, "url").String()}, nil

ee/sqlstore/postgressqlstore/provider.go

@@ -101,7 +101,7 @@ func (provider *provider) WrapNotFoundErrf(err error, code errors.Code, format s
 
 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" || pgErr.Code == "23503") {
+	if errors.As(err, &pgErr) && pgErr.Code == "23505" {
 		return errors.Wrapf(err, errors.TypeAlreadyExists, code, format, args...)
 	}
 

frontend/.eslintrc.cjs

@@ -193,16 +193,6 @@ module.exports = {
 				],
 			},
 		],
-		'no-restricted-syntax': [
-			'error',
-			{
-				selector:
-					// TODO: Make this generic on removal of redux
-					"CallExpression[callee.property.name='getState'][callee.object.name=/^use/]",
-				message:
-					'Avoid calling .getState() directly. Export a standalone action from the store instead.',
-			},
-		],
 	},
 	overrides: [
 		{
@@ -227,13 +217,5 @@ module.exports = {
 				'@typescript-eslint/no-unused-vars': 'warn',
 			},
 		},
-		{
-			// Store definition files are the only place .getState() is permitted —
-			// they are the canonical source for standalone action exports.
-			files: ['**/*Store.{ts,tsx}'],
-			rules: {
-				'no-restricted-syntax': 'off',
-			},
-		},
 	],
 };

frontend/src/api/generated/services/sigNoz.schemas.ts

@@ -776,45 +776,6 @@ export interface GatewaytypesUpdatableIngestionKeyLimitDTO {
 	tags?: string[] | null;
 }
 
-export interface GlobaltypesAPIKeyConfigDTO {
-	/**
-	 * @type boolean
-	 */
-	enabled?: boolean;
-}
-
-export interface GlobaltypesConfigDTO {
-	/**
-	 * @type string
-	 */
-	external_url?: string;
-	identN?: GlobaltypesIdentNConfigDTO;
-	/**
-	 * @type string
-	 */
-	ingestion_url?: string;
-}
-
-export interface GlobaltypesIdentNConfigDTO {
-	apikey?: GlobaltypesAPIKeyConfigDTO;
-	impersonation?: GlobaltypesImpersonationConfigDTO;
-	tokenizer?: GlobaltypesTokenizerConfigDTO;
-}
-
-export interface GlobaltypesImpersonationConfigDTO {
-	/**
-	 * @type boolean
-	 */
-	enabled?: boolean;
-}
-
-export interface GlobaltypesTokenizerConfigDTO {
-	/**
-	 * @type boolean
-	 */
-	enabled?: boolean;
-}
-
 export interface MetricsexplorertypesListMetricDTO {
 	/**
 	 * @type string
@@ -2441,6 +2402,17 @@ export interface TypesGettableAPIKeyDTO {
 	userId?: string;
 }
 
+export interface TypesGettableGlobalConfigDTO {
+	/**
+	 * @type string
+	 */
+	external_url?: string;
+	/**
+	 * @type string
+	 */
+	ingestion_url?: string;
+}
+
 export interface TypesIdentifiableDTO {
 	/**
 	 * @type string
@@ -2539,25 +2511,6 @@ export interface TypesPostableAPIKeyDTO {
 	role?: string;
 }
 
-export interface TypesPostableAcceptInviteDTO {
-	/**
-	 * @type string
-	 */
-	displayName?: string;
-	/**
-	 * @type string
-	 */
-	password?: string;
-	/**
-	 * @type string
-	 */
-	sourceUrl?: string;
-	/**
-	 * @type string
-	 */
-	token?: string;
-}
-
 export interface TypesPostableBulkInviteRequestDTO {
 	/**
 	 * @type array
@@ -3054,18 +3007,7 @@ export type GetResetPasswordToken200 = {
 };
 
 export type GetGlobalConfig200 = {
-	data: GlobaltypesConfigDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type ListInvite200 = {
-	/**
-	 * @type array
-	 */
-	data: TypesInviteDTO[];
+	data: TypesGettableGlobalConfigDTO;
 	/**
 	 * @type string
 	 */
@@ -3080,28 +3022,6 @@ export type CreateInvite201 = {
 	status: string;
 };
 
-export type DeleteInvitePathParameters = {
-	id: string;
-};
-export type GetInvitePathParameters = {
-	token: string;
-};
-export type GetInvite200 = {
-	data: TypesInviteDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type AcceptInvite201 = {
-	data: TypesUserDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type ListPromotedAndIndexedPaths200 = {
 	/**
 	 * @type array

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

@@ -20,26 +20,20 @@ import { useMutation, useQuery } from 'react-query';
 import type { BodyType, ErrorType } from '../../../generatedAPIInstance';
 import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
 import type {
-	AcceptInvite201,
 	ChangePasswordPathParameters,
 	CreateAPIKey201,
 	CreateInvite201,
-	DeleteInvitePathParameters,
 	DeleteUserPathParameters,
-	GetInvite200,
-	GetInvitePathParameters,
 	GetMyUser200,
 	GetResetPasswordToken200,
 	GetResetPasswordTokenPathParameters,
 	GetUser200,
 	GetUserPathParameters,
 	ListAPIKeys200,
-	ListInvite200,
 	ListUsers200,
 	RenderErrorResponseDTO,
 	RevokeAPIKeyPathParameters,
 	TypesChangePasswordRequestDTO,
-	TypesPostableAcceptInviteDTO,
 	TypesPostableAPIKeyDTO,
 	TypesPostableBulkInviteRequestDTO,
 	TypesPostableForgotPasswordDTO,
@@ -255,84 +249,6 @@ export const invalidateGetResetPasswordToken = async (
 	return queryClient;
 };
 
-/**
- * This endpoint lists all invites
- * @summary List invites
- */
-export const listInvite = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<ListInvite200>({
-		url: `/api/v1/invite`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getListInviteQueryKey = () => {
-	return [`/api/v1/invite`] as const;
-};
-
-export const getListInviteQueryOptions = <
-	TData = Awaited<ReturnType<typeof listInvite>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(options?: {
-	query?: UseQueryOptions<Awaited<ReturnType<typeof listInvite>>, TError, TData>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getListInviteQueryKey();
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof listInvite>>> = ({
-		signal,
-	}) => listInvite(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listInvite>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListInviteQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listInvite>>
->;
-export type ListInviteQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List invites
- */
-
-export function useListInvite<
-	TData = Awaited<ReturnType<typeof listInvite>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(options?: {
-	query?: UseQueryOptions<Awaited<ReturnType<typeof listInvite>>, TError, TData>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListInviteQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary List invites
- */
-export const invalidateListInvite = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListInviteQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};
-
 /**
  * This endpoint creates an invite for a user
  * @summary Create invite
@@ -416,257 +332,6 @@ export const useCreateInvite = <
 
 	return useMutation(mutationOptions);
 };
-/**
- * This endpoint deletes an invite by id
- * @summary Delete invite
- */
-export const deleteInvite = ({ id }: DeleteInvitePathParameters) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/invite/${id}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeleteInviteMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteInvite>>,
-		TError,
-		{ pathParams: DeleteInvitePathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteInvite>>,
-	TError,
-	{ pathParams: DeleteInvitePathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteInvite'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-		  'mutationKey' in options.mutation &&
-		  options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof deleteInvite>>,
-		{ pathParams: DeleteInvitePathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteInvite(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteInviteMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteInvite>>
->;
-
-export type DeleteInviteMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete invite
- */
-export const useDeleteInvite = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteInvite>>,
-		TError,
-		{ pathParams: DeleteInvitePathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteInvite>>,
-	TError,
-	{ pathParams: DeleteInvitePathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeleteInviteMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * This endpoint gets an invite by token
- * @summary Get invite
- */
-export const getInvite = (
-	{ token }: GetInvitePathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetInvite200>({
-		url: `/api/v1/invite/${token}`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetInviteQueryKey = ({ token }: GetInvitePathParameters) => {
-	return [`/api/v1/invite/${token}`] as const;
-};
-
-export const getGetInviteQueryOptions = <
-	TData = Awaited<ReturnType<typeof getInvite>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ token }: GetInvitePathParameters,
-	options?: {
-		query?: UseQueryOptions<Awaited<ReturnType<typeof getInvite>>, TError, TData>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getGetInviteQueryKey({ token });
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof getInvite>>> = ({
-		signal,
-	}) => getInvite({ token }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!token,
-		...queryOptions,
-	} as UseQueryOptions<Awaited<ReturnType<typeof getInvite>>, TError, TData> & {
-		queryKey: QueryKey;
-	};
-};
-
-export type GetInviteQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getInvite>>
->;
-export type GetInviteQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get invite
- */
-
-export function useGetInvite<
-	TData = Awaited<ReturnType<typeof getInvite>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ token }: GetInvitePathParameters,
-	options?: {
-		query?: UseQueryOptions<Awaited<ReturnType<typeof getInvite>>, TError, TData>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetInviteQueryOptions({ token }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get invite
- */
-export const invalidateGetInvite = async (
-	queryClient: QueryClient,
-	{ token }: GetInvitePathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetInviteQueryKey({ token }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint accepts an invite by token
- * @summary Accept invite
- */
-export const acceptInvite = (
-	typesPostableAcceptInviteDTO: BodyType<TypesPostableAcceptInviteDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<AcceptInvite201>({
-		url: `/api/v1/invite/accept`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: typesPostableAcceptInviteDTO,
-		signal,
-	});
-};
-
-export const getAcceptInviteMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof acceptInvite>>,
-		TError,
-		{ data: BodyType<TypesPostableAcceptInviteDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof acceptInvite>>,
-	TError,
-	{ data: BodyType<TypesPostableAcceptInviteDTO> },
-	TContext
-> => {
-	const mutationKey = ['acceptInvite'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-		  'mutationKey' in options.mutation &&
-		  options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof acceptInvite>>,
-		{ data: BodyType<TypesPostableAcceptInviteDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return acceptInvite(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type AcceptInviteMutationResult = NonNullable<
-	Awaited<ReturnType<typeof acceptInvite>>
->;
-export type AcceptInviteMutationBody = BodyType<TypesPostableAcceptInviteDTO>;
-export type AcceptInviteMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Accept invite
- */
-export const useAcceptInvite = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof acceptInvite>>,
-		TError,
-		{ data: BodyType<TypesPostableAcceptInviteDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof acceptInvite>>,
-	TError,
-	{ data: BodyType<TypesPostableAcceptInviteDTO> },
-	TContext
-> => {
-	const mutationOptions = getAcceptInviteMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
 /**
  * This endpoint creates a bulk invite for a user
  * @summary Create bulk invite

frontend/src/api/index.ts

@@ -81,8 +81,7 @@ export const interceptorRejected = async (
 				response.config.url !== '/sessions/email_password' &&
 				!(
 					response.config.url === '/sessions' && response.config.method === 'delete'
-				) &&
-				response.config.url !== '/authz/check'
+				)
 			) {
 				try {
 					const accessToken = getLocalStorageApi(LOCALSTORAGE.AUTH_TOKEN);

frontend/src/api/interceptors.test.ts

@@ -1,152 +0,0 @@
-import axios, { AxiosHeaders, AxiosResponse } from 'axios';
-
-import { interceptorRejected } from './index';
-
-jest.mock('api/browser/localstorage/get', () => ({
-	__esModule: true,
-	default: jest.fn(() => 'mock-token'),
-}));
-
-jest.mock('api/v2/sessions/rotate/post', () => ({
-	__esModule: true,
-	default: jest.fn(() =>
-		Promise.resolve({
-			data: { accessToken: 'new-token', refreshToken: 'new-refresh' },
-		}),
-	),
-}));
-
-jest.mock('AppRoutes/utils', () => ({
-	__esModule: true,
-	default: jest.fn(),
-}));
-
-jest.mock('axios', () => {
-	const actualAxios = jest.requireActual('axios');
-	const mockAxios = jest.fn().mockResolvedValue({ data: 'success' });
-
-	return {
-		...actualAxios,
-		default: Object.assign(mockAxios, {
-			...actualAxios.default,
-			isAxiosError: jest.fn().mockReturnValue(true),
-			create: actualAxios.create,
-		}),
-		__esModule: true,
-	};
-});
-
-describe('interceptorRejected', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-		((axios as unknown) as jest.Mock).mockResolvedValue({ data: 'success' });
-		((axios.isAxiosError as unknown) as jest.Mock).mockReturnValue(true);
-	});
-
-	it('should preserve array payload structure when retrying a 401 request', async () => {
-		const arrayPayload = [
-			{ relation: 'assignee', object: { resource: { name: 'role' } } },
-			{ relation: 'assignee', object: { resource: { name: 'editor' } } },
-		];
-
-		const error = ({
-			response: {
-				status: 401,
-				config: {
-					url: '/some-endpoint',
-					method: 'POST',
-					baseURL: 'http://localhost/',
-					headers: new AxiosHeaders(),
-					data: JSON.stringify(arrayPayload),
-				},
-			},
-			config: {
-				url: '/some-endpoint',
-				method: 'POST',
-				baseURL: 'http://localhost/',
-				headers: new AxiosHeaders(),
-				data: JSON.stringify(arrayPayload),
-			},
-		} as unknown) as AxiosResponse;
-
-		try {
-			await interceptorRejected(error);
-		} catch {
-			// Expected to reject after retry
-		}
-
-		const mockAxiosFn = (axios as unknown) as jest.Mock;
-		expect(mockAxiosFn.mock.calls.length).toBe(1);
-		const retryCallConfig = mockAxiosFn.mock.calls[0][0];
-		expect(Array.isArray(JSON.parse(retryCallConfig.data))).toBe(true);
-		expect(JSON.parse(retryCallConfig.data)).toEqual(arrayPayload);
-	});
-
-	it('should preserve object payload structure when retrying a 401 request', async () => {
-		const objectPayload = { key: 'value', nested: { data: 123 } };
-
-		const error = ({
-			response: {
-				status: 401,
-				config: {
-					url: '/some-endpoint',
-					method: 'POST',
-					baseURL: 'http://localhost/',
-					headers: new AxiosHeaders(),
-					data: JSON.stringify(objectPayload),
-				},
-			},
-			config: {
-				url: '/some-endpoint',
-				method: 'POST',
-				baseURL: 'http://localhost/',
-				headers: new AxiosHeaders(),
-				data: JSON.stringify(objectPayload),
-			},
-		} as unknown) as AxiosResponse;
-
-		try {
-			await interceptorRejected(error);
-		} catch {
-			// Expected to reject after retry
-		}
-
-		const mockAxiosFn = (axios as unknown) as jest.Mock;
-		expect(mockAxiosFn.mock.calls.length).toBe(1);
-		const retryCallConfig = mockAxiosFn.mock.calls[0][0];
-		expect(JSON.parse(retryCallConfig.data)).toEqual(objectPayload);
-	});
-
-	it('should handle undefined data gracefully when retrying', async () => {
-		const error = ({
-			response: {
-				status: 401,
-				config: {
-					url: '/some-endpoint',
-					method: 'GET',
-					baseURL: 'http://localhost/',
-					headers: new AxiosHeaders(),
-					data: undefined,
-				},
-			},
-			config: {
-				url: '/some-endpoint',
-				method: 'GET',
-				baseURL: 'http://localhost/',
-				headers: new AxiosHeaders(),
-				data: undefined,
-			},
-		} as unknown) as AxiosResponse;
-
-		try {
-			await interceptorRejected(error);
-		} catch {
-			// Expected to reject after retry
-		}
-
-		const mockAxiosFn = (axios as unknown) as jest.Mock;
-		expect(mockAxiosFn.mock.calls.length).toBe(1);
-		const retryCallConfig = mockAxiosFn.mock.calls[0][0];
-		expect(retryCallConfig.data).toBeUndefined();
-	});
-});

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

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

frontend/src/api/v1/invite/id/accept.ts

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

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

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

frontend/src/api/v1/invite/id/get.ts

@@ -1,28 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
-import { AxiosError } from 'axios';
-import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
-import {
-	InviteDetails,
-	PayloadProps,
-	Props,
-} from 'types/api/user/getInviteDetails';
-
-const getInviteDetails = async (
-	props: Props,
-): Promise<SuccessResponseV2<InviteDetails>> => {
-	try {
-		const response = await axios.get<PayloadProps>(
-			`/invite/${props.inviteId}?ref=${window.location.href}`,
-		);
-
-		return {
-			httpStatusCode: response.status,
-			data: response.data.data,
-		};
-	} catch (error) {
-		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
-	}
-};
-
-export default getInviteDetails;

frontend/src/assets/UnAuthorized.tsx

@@ -1,14 +1,8 @@
-function UnAuthorized({
-	width = 137,
-	height = 137,
-}: {
-	height?: number;
-	width?: number;
-}): JSX.Element {
+function UnAuthorized(): JSX.Element {
 	return (
 		<svg
-			width={width}
-			height={height}
+			width="137"
+			height="137"
 			viewBox="0 0 137 137"
 			fill="none"
 			xmlns="http://www.w3.org/2000/svg"

frontend/src/components/EditMemberDrawer/EditMemberDrawer.tsx

@@ -7,7 +7,6 @@ import {
 	Check,
 	ChevronDown,
 	Copy,
-	Link,
 	LockKeyhole,
 	RefreshCw,
 	Trash2,
@@ -17,14 +16,11 @@ import { Input } from '@signozhq/input';
 import { toast } from '@signozhq/sonner';
 import { Select } from 'antd';
 import getResetPasswordToken from 'api/v1/factor_password/getResetPasswordToken';
-import sendInvite from 'api/v1/invite/create';
-import cancelInvite from 'api/v1/invite/id/delete';
 import deleteUser from 'api/v1/user/id/delete';
 import update from 'api/v1/user/id/update';
 import { MemberRow } from 'components/MembersTable/MembersTable';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
-import ROUTES from 'constants/routes';
-import { INVITE_PREFIX, MemberStatus } from 'container/MembersSettings/utils';
+import { MemberStatus } from 'container/MembersSettings/utils';
 import { capitalize } from 'lodash-es';
 import { useTimezone } from 'providers/Timezone';
 import { ROLES } from 'types/roles';
@@ -36,7 +32,6 @@ export interface EditMemberDrawerProps {
 	open: boolean;
 	onClose: () => void;
 	onComplete: () => void;
-	onRefetch?: () => void;
 }
 
 // eslint-disable-next-line sonarjs/cognitive-complexity
@@ -45,7 +40,6 @@ function EditMemberDrawer({
 	open,
 	onClose,
 	onComplete,
-	onRefetch,
 }: EditMemberDrawerProps): JSX.Element {
 	const { formatTimezoneAdjustedTimestamp } = useTimezone();
 
@@ -58,11 +52,9 @@ function EditMemberDrawer({
 	const [resetLink, setResetLink] = useState<string | null>(null);
 	const [showResetLinkDialog, setShowResetLinkDialog] = useState(false);
 	const [hasCopiedResetLink, setHasCopiedResetLink] = useState(false);
+	const [linkType, setLinkType] = useState<'invite' | 'reset' | null>(null);
 
 	const isInvited = member?.status === MemberStatus.Invited;
-	// Invited member IDs are prefixed with 'invite-'; strip it to get the real invite ID
-	const inviteId =
-		isInvited && member ? member.id.slice(INVITE_PREFIX.length) : null;
 
 	useEffect(() => {
 		if (member) {
@@ -73,7 +65,7 @@ function EditMemberDrawer({
 
 	const isDirty =
 		member !== null &&
-		(displayName !== member.name || selectedRole !== member.role);
+		(displayName !== (member.name ?? '') || selectedRole !== member.role);
 
 	const formatTimestamp = useCallback(
 		(ts: string | null | undefined): string => {
@@ -89,80 +81,22 @@ function EditMemberDrawer({
 		[formatTimezoneAdjustedTimestamp],
 	);
 
-	const saveInvitedMember = useCallback(async (): Promise<void> => {
-		if (!member || !inviteId) {
-			return;
-		}
-		await cancelInvite({ id: inviteId });
-		try {
-			await sendInvite({
-				email: member.email,
-				name: displayName,
-				role: selectedRole,
-				frontendBaseUrl: window.location.origin,
-			});
-			toast.success('Invite updated successfully', { richColors: true });
-			onComplete();
-			onClose();
-		} catch {
-			onRefetch?.();
-			onClose();
-			toast.error(
-				'Failed to send the updated invite. Please re-invite this member.',
-				{ richColors: true },
-			);
-		}
-	}, [
-		member,
-		inviteId,
-		displayName,
-		selectedRole,
-		onComplete,
-		onClose,
-		onRefetch,
-	]);
-
-	const saveActiveMember = useCallback(async (): Promise<void> => {
-		if (!member) {
-			return;
-		}
-		await update({
-			userId: member.id,
-			displayName,
-			role: selectedRole,
-		});
-		toast.success('Member details updated successfully', { richColors: true });
-		onComplete();
-		onClose();
-	}, [member, displayName, selectedRole, onComplete, onClose]);
-
 	const handleSave = useCallback(async (): Promise<void> => {
 		if (!member || !isDirty) {
 			return;
 		}
 		setIsSaving(true);
 		try {
-			if (isInvited && inviteId) {
-				await saveInvitedMember();
-			} else {
-				await saveActiveMember();
-			}
+			await update({ userId: member.id, displayName, role: selectedRole });
+			toast.success('Member details updated successfully', { richColors: true });
+			onComplete();
+			onClose();
 		} catch {
-			toast.error(
-				isInvited ? 'Failed to update invite' : 'Failed to update member details',
-				{ richColors: true },
-			);
+			toast.error('Failed to update member details', { richColors: true });
 		} finally {
 			setIsSaving(false);
 		}
-	}, [
-		member,
-		isDirty,
-		isInvited,
-		inviteId,
-		saveInvitedMember,
-		saveActiveMember,
-	]);
+	}, [member, isDirty, displayName, selectedRole, onComplete, onClose]);
 
 	const handleDelete = useCallback(async (): Promise<void> => {
 		if (!member) {
@@ -170,25 +104,23 @@ function EditMemberDrawer({
 		}
 		setIsDeleting(true);
 		try {
-			if (isInvited && inviteId) {
-				await cancelInvite({ id: inviteId });
-				toast.success('Invitation cancelled successfully', { richColors: true });
-			} else {
-				await deleteUser({ userId: member.id });
-				toast.success('Member deleted successfully', { richColors: true });
-			}
+			await deleteUser({ userId: member.id });
+			toast.success(
+				isInvited ? 'Invite revoked successfully' : 'Member deleted successfully',
+				{ richColors: true },
+			);
 			setShowDeleteConfirm(false);
 			onComplete();
 			onClose();
 		} catch {
 			toast.error(
-				isInvited ? 'Failed to cancel invitation' : 'Failed to delete member',
+				isInvited ? 'Failed to revoke invite' : 'Failed to delete member',
 				{ richColors: true },
 			);
 		} finally {
 			setIsDeleting(false);
 		}
-	}, [member, isInvited, inviteId, onComplete, onClose]);
+	}, [member, isInvited, onComplete, onClose]);
 
 	const handleGenerateResetLink = useCallback(async (): Promise<void> => {
 		if (!member) {
@@ -201,6 +133,7 @@ function EditMemberDrawer({
 				const link = `${window.location.origin}/password-reset?token=${response.data.token}`;
 				setResetLink(link);
 				setHasCopiedResetLink(false);
+				setLinkType(isInvited ? 'invite' : 'reset');
 				setShowResetLinkDialog(true);
 				onClose();
 			} else {
@@ -217,7 +150,7 @@ function EditMemberDrawer({
 		} finally {
 			setIsGeneratingLink(false);
 		}
-	}, [member, onClose]);
+	}, [member, isInvited, setLinkType, onClose]);
 
 	const handleCopyResetLink = useCallback(async (): Promise<void> => {
 		if (!resetLink) {
@@ -227,36 +160,18 @@ function EditMemberDrawer({
 			await navigator.clipboard.writeText(resetLink);
 			setHasCopiedResetLink(true);
 			setTimeout(() => setHasCopiedResetLink(false), 2000);
-			toast.success('Reset link copied to clipboard', { richColors: true });
+			toast.success(
+				linkType === 'invite'
+					? 'Invite link copied to clipboard'
+					: 'Reset link copied to clipboard',
+				{ richColors: true },
+			);
 		} catch {
 			toast.error('Failed to copy link', {
 				richColors: true,
 			});
 		}
-	}, [resetLink]);
-
-	const handleCopyInviteLink = useCallback(async (): Promise<void> => {
-		if (!member?.token) {
-			toast.error('Invite link is not available', {
-				richColors: true,
-				position: 'top-right',
-			});
-			return;
-		}
-		const inviteLink = `${window.location.origin}${ROUTES.SIGN_UP}?token=${member.token}`;
-		try {
-			await navigator.clipboard.writeText(inviteLink);
-			toast.success('Invite link copied to clipboard', {
-				richColors: true,
-				position: 'top-right',
-			});
-		} catch {
-			toast.error('Failed to copy invite link', {
-				richColors: true,
-				position: 'top-right',
-			});
-		}
-	}, [member]);
+	}, [resetLink, linkType]);
 
 	const handleClose = useCallback((): void => {
 		setShowDeleteConfirm(false);
@@ -348,30 +263,22 @@ function EditMemberDrawer({
 						onClick={(): void => setShowDeleteConfirm(true)}
 					>
 						<Trash2 size={12} />
-						{isInvited ? 'Cancel Invite' : 'Delete Member'}
+						{isInvited ? 'Revoke Invite' : 'Delete Member'}
 					</Button>
 
 					<div className="edit-member-drawer__footer-divider" />
-
-					{isInvited ? (
-						<Button
-							className="edit-member-drawer__footer-btn edit-member-drawer__footer-btn--warning"
-							onClick={handleCopyInviteLink}
-							disabled={!member?.token}
-						>
-							<Link size={12} />
-							Copy Invite Link
-						</Button>
-					) : (
-						<Button
-							className="edit-member-drawer__footer-btn edit-member-drawer__footer-btn--warning"
-							onClick={handleGenerateResetLink}
-							disabled={isGeneratingLink}
-						>
-							<RefreshCw size={12} />
-							{isGeneratingLink ? 'Generating...' : 'Generate Password Reset Link'}
-						</Button>
-					)}
+					<Button
+						className="edit-member-drawer__footer-btn edit-member-drawer__footer-btn--warning"
+						onClick={handleGenerateResetLink}
+						disabled={isGeneratingLink}
+					>
+						<RefreshCw size={12} />
+						{isGeneratingLink
+							? 'Generating...'
+							: isInvited
+							? 'Copy Invite Link'
+							: 'Generate Password Reset Link'}
+					</Button>
 				</div>
 
 				<div className="edit-member-drawer__footer-right">
@@ -394,21 +301,21 @@ function EditMemberDrawer({
 		</div>
 	);
 
-	const deleteDialogTitle = isInvited ? 'Cancel Invitation' : 'Delete Member';
+	const deleteDialogTitle = isInvited ? 'Revoke Invite' : 'Delete Member';
 	const deleteDialogBody = isInvited ? (
 		<>
-			Are you sure you want to cancel the invitation for{' '}
+			Are you sure you want to revoke the invite for{' '}
 			<strong>{member?.email}</strong>? They will no longer be able to join the
 			workspace using this invite.
 		</>
 	) : (
 		<>
 			Are you sure you want to delete{' '}
-			<strong>{member?.name || member?.email}</strong>? This will permanently
-			remove their access to the workspace.
+			<strong>{member?.name || member?.email}</strong>? This will remove their
+			access to the workspace.
 		</>
 	);
-	const deleteConfirmLabel = isInvited ? 'Cancel Invite' : 'Delete Member';
+	const deleteConfirmLabel = isInvited ? 'Revoke Invite' : 'Delete Member';
 
 	return (
 		<>
@@ -434,17 +341,19 @@ function EditMemberDrawer({
 				onOpenChange={(isOpen): void => {
 					if (!isOpen) {
 						setShowResetLinkDialog(false);
+						setLinkType(null);
 					}
 				}}
-				title="Password Reset Link"
+				title={linkType === 'invite' ? 'Invite Link' : 'Password Reset Link'}
 				showCloseButton
 				width="base"
 				className="reset-link-dialog"
 			>
 				<div className="reset-link-dialog__content">
 					<p className="reset-link-dialog__description">
-						This creates a one-time link the team member can use to set a new password
-						for their SigNoz account.
+						{linkType === 'invite'
+							? 'Share this one-time link with the team member to complete their account setup.'
+							: 'This creates a one-time link the team member can use to set a new password for their SigNoz account.'}
 					</p>
 					<div className="reset-link-dialog__link-row">
 						<div className="reset-link-dialog__link-text-wrap">

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

@@ -1,7 +1,6 @@
 import type { ReactNode } from 'react';
 import { toast } from '@signozhq/sonner';
 import getResetPasswordToken from 'api/v1/factor_password/getResetPasswordToken';
-import cancelInvite from 'api/v1/invite/id/delete';
 import deleteUser from 'api/v1/user/id/delete';
 import update from 'api/v1/user/id/update';
 import { MemberStatus } from 'container/MembersSettings/utils';
@@ -48,8 +47,6 @@ jest.mock('@signozhq/dialog', () => ({
 
 jest.mock('api/v1/user/id/update');
 jest.mock('api/v1/user/id/delete');
-jest.mock('api/v1/invite/id/delete');
-jest.mock('api/v1/invite/create');
 jest.mock('api/v1/factor_password/getResetPasswordToken');
 jest.mock('@signozhq/sonner', () => ({
 	toast: {
@@ -60,7 +57,6 @@ jest.mock('@signozhq/sonner', () => ({
 
 const mockUpdate = jest.mocked(update);
 const mockDeleteUser = jest.mocked(deleteUser);
-const mockCancelInvite = jest.mocked(cancelInvite);
 const mockGetResetPasswordToken = jest.mocked(getResetPasswordToken);
 
 const activeMember = {
@@ -74,13 +70,12 @@ const activeMember = {
 };
 
 const invitedMember = {
-	id: 'invite-abc123',
+	id: 'abc123',
 	name: '',
 	email: 'bob@signoz.io',
 	role: 'VIEWER' as ROLES,
 	status: MemberStatus.Invited,
 	joinedOn: '1700000000000',
-	token: 'tok-xyz',
 };
 
 function renderDrawer(
@@ -102,7 +97,6 @@ describe('EditMemberDrawer', () => {
 		jest.clearAllMocks();
 		mockUpdate.mockResolvedValue({ httpStatusCode: 200, data: null });
 		mockDeleteUser.mockResolvedValue({ httpStatusCode: 200, data: null });
-		mockCancelInvite.mockResolvedValue({ httpStatusCode: 200, data: null });
 	});
 
 	it('renders active member details and disables Save when form is not dirty', () => {
@@ -163,36 +157,61 @@ describe('EditMemberDrawer', () => {
 		});
 	});
 
-	it('shows Cancel Invite and Copy Invite Link for invited members; hides Last Modified', () => {
+	it('shows revoke invite and copy invite link for invited members; hides Last Modified', () => {
 		renderDrawer({ member: invitedMember });
 
 		expect(
-			screen.getByRole('button', { name: /cancel invite/i }),
+			screen.getByRole('button', { name: /revoke invite/i }),
 		).toBeInTheDocument();
 		expect(
 			screen.getByRole('button', { name: /copy invite link/i }),
 		).toBeInTheDocument();
+		expect(
+			screen.queryByRole('button', { name: /generate password reset link/i }),
+		).not.toBeInTheDocument();
 		expect(screen.getByText('Invited On')).toBeInTheDocument();
 		expect(screen.queryByText('Last Modified')).not.toBeInTheDocument();
 	});
 
-	it('calls cancelInvite after confirming Cancel Invite for invited members', async () => {
+	it('calls deleteUser after confirming revoke invite for invited members', async () => {
 		const onComplete = jest.fn();
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 
 		renderDrawer({ member: invitedMember, onComplete });
 
-		await user.click(screen.getByRole('button', { name: /cancel invite/i }));
+		await user.click(screen.getByRole('button', { name: /revoke invite/i }));
 
 		expect(
-			await screen.findByText(/are you sure you want to cancel the invitation/i),
+			await screen.findByText(/Are you sure you want to revoke the invite/i),
 		).toBeInTheDocument();
 
-		const confirmBtns = screen.getAllByRole('button', { name: /cancel invite/i });
+		const confirmBtns = screen.getAllByRole('button', { name: /revoke invite/i });
 		await user.click(confirmBtns[confirmBtns.length - 1]);
 
 		await waitFor(() => {
-			expect(mockCancelInvite).toHaveBeenCalledWith({ id: 'abc123' });
+			expect(mockDeleteUser).toHaveBeenCalledWith({ userId: 'abc123' });
+			expect(onComplete).toHaveBeenCalled();
+		});
+	});
+
+	it('calls update API when saving changes for an invited member', async () => {
+		const onComplete = jest.fn();
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+		renderDrawer({ member: { ...invitedMember, name: 'Bob' }, onComplete });
+
+		const nameInput = screen.getByDisplayValue('Bob');
+		await user.clear(nameInput);
+		await user.type(nameInput, 'Bob Updated');
+
+		const saveBtn = screen.getByRole('button', { name: /save member details/i });
+		await waitFor(() => expect(saveBtn).not.toBeDisabled());
+		await user.click(saveBtn);
+
+		await waitFor(() => {
+			expect(mockUpdate).toHaveBeenCalledWith(
+				expect.objectContaining({ userId: 'abc123', displayName: 'Bob Updated' }),
+			);
 			expect(onComplete).toHaveBeenCalled();
 		});
 	});
@@ -260,7 +279,6 @@ describe('EditMemberDrawer', () => {
 
 			fireEvent.click(screen.getByRole('button', { name: /^copy$/i }));
 
-			// Verify success path: writeText called with the correct link
 			await waitFor(() => {
 				expect(mockToast.success).toHaveBeenCalledWith(
 					'Reset link copied to clipboard',

frontend/src/components/MembersTable/MembersTable.tsx

@@ -1,6 +1,6 @@
 import type React from 'react';
 import { Badge } from '@signozhq/badge';
-import { Pagination, Table, Tooltip } from 'antd';
+import { Table, Tooltip } from 'antd';
 import type { ColumnsType, SorterResult } from 'antd/es/table/interface';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
 import { MemberStatus } from 'container/MembersSettings/utils';
@@ -18,7 +18,6 @@ export interface MemberRow {
 	status: MemberStatus;
 	joinedOn: string | null;
 	updatedAt?: string | null;
-	token?: string | null;
 }
 
 interface MembersTableProps {
@@ -64,11 +63,23 @@ function StatusBadge({ status }: { status: MemberRow['status'] }): JSX.Element {
 			</Badge>
 		);
 	}
-	return (
-		<Badge color="amber" variant="outline">
-			INVITED
-		</Badge>
-	);
+	if (status === MemberStatus.Deleted) {
+		return (
+			<Badge color="cherry" variant="outline">
+				DELETED
+			</Badge>
+		);
+	}
+
+	if (status === MemberStatus.Invited) {
+		return (
+			<Badge color="amber" variant="outline">
+				INVITED
+			</Badge>
+		);
+	}
+
+	return <Badge color="vanilla">⎯</Badge>;
 }
 
 function MembersEmptyState({
@@ -199,14 +210,30 @@ function MembersTable({
 				dataSource={data}
 				rowKey="id"
 				loading={loading}
-				pagination={false}
+				pagination={{
+					current: currentPage,
+					pageSize,
+					total,
+					showTotal: showPaginationTotal,
+					showSizeChanger: false,
+					onChange: onPageChange,
+					className: 'members-table-pagination',
+					hideOnSinglePage: true,
+				}}
 				rowClassName={(_, index): string =>
 					index % 2 === 0 ? 'members-table-row--tinted' : ''
 				}
-				onRow={(record): React.HTMLAttributes<HTMLElement> => ({
-					onClick: (): void => onRowClick?.(record),
-					style: onRowClick ? { cursor: 'pointer' } : undefined,
-				})}
+				onRow={(record): React.HTMLAttributes<HTMLElement> => {
+					const isClickable = onRowClick && record.status !== MemberStatus.Deleted;
+					return {
+						onClick: (): void => {
+							if (isClickable) {
+								onRowClick(record);
+							}
+						},
+						style: isClickable ? { cursor: 'pointer' } : undefined,
+					};
+				}}
 				onChange={(_, __, sorter): void => {
 					if (onSortChange) {
 						onSortChange(
@@ -220,17 +247,6 @@ function MembersTable({
 				}}
 				className="members-table"
 			/>
-			{total > pageSize && (
-				<Pagination
-					current={currentPage}
-					pageSize={pageSize}
-					total={total}
-					showTotal={showPaginationTotal}
-					showSizeChanger={false}
-					onChange={onPageChange}
-					className="members-table-pagination"
-				/>
-			)}
 		</div>
 	);
 }

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

@@ -24,13 +24,12 @@ const mockActiveMembers: MemberRow[] = [
 ];
 
 const mockInvitedMember: MemberRow = {
-	id: 'invite-abc',
+	id: 'inv-abc',
 	name: '',
 	email: 'charlie@signoz.io',
 	role: 'EDITOR' as ROLES,
 	status: MemberStatus.Invited,
 	joinedOn: null,
-	token: 'tok-123',
 };
 
 const defaultProps = {
@@ -93,6 +92,34 @@ describe('MembersTable', () => {
 		);
 	});
 
+	it('renders DELETED badge and does not call onRowClick when a deleted member row is clicked', async () => {
+		const onRowClick = jest.fn();
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		const deletedMember: MemberRow = {
+			id: 'user-del',
+			name: 'Dave Deleted',
+			email: 'dave@signoz.io',
+			role: 'VIEWER' as ROLES,
+			status: MemberStatus.Deleted,
+			joinedOn: null,
+		};
+
+		render(
+			<MembersTable
+				{...defaultProps}
+				data={[...mockActiveMembers, deletedMember]}
+				total={3}
+				onRowClick={onRowClick}
+			/>,
+		);
+
+		expect(screen.getByText('DELETED')).toBeInTheDocument();
+		await user.click(screen.getByText('Dave Deleted'));
+		expect(onRowClick).not.toHaveBeenCalledWith(
+			expect.objectContaining({ id: 'user-del' }),
+		);
+	});
+
 	it('shows "No members found" empty state when no data and no search query', () => {
 		render(<MembersTable {...defaultProps} data={[]} total={0} searchQuery="" />);
 

frontend/src/components/ShiftOverlay/ShiftHoldOverlayController.tsx

@@ -1,13 +1,13 @@
 import { createShortcutActions } from '../../constants/shortcutActions';
 import { useCmdK } from '../../providers/cmdKProvider';
-import { ROLES } from '../../types/roles';
 import { ShiftOverlay } from './ShiftOverlay';
 import { useShiftHoldOverlay } from './useShiftHoldOverlay';
 
+type UserRole = 'ADMIN' | 'EDITOR' | 'AUTHOR' | 'VIEWER';
 export function ShiftHoldOverlayController({
 	userRole,
 }: {
-	userRole: ROLES;
+	userRole: UserRole;
 }): JSX.Element | null {
 	const { open: isCmdKOpen } = useCmdK();
 	const noop = (): void => undefined;

frontend/src/components/ShiftOverlay/ShiftOverlay.tsx

@@ -1,18 +1,18 @@
 import { useMemo } from 'react';
 import ReactDOM from 'react-dom';
-import { ROLES } from 'types/roles';
 
 import { formatShortcut } from './formatShortcut';
 
 import './shiftOverlay.scss';
 
+export type UserRole = 'ADMIN' | 'EDITOR' | 'AUTHOR' | 'VIEWER';
 export type CmdAction = {
 	id: string;
 	name: string;
 	shortcut?: string[];
 	keywords?: string;
 	section?: string;
-	roles?: ROLES[];
+	roles?: UserRole[];
 	perform: () => void;
 };
 
@@ -33,7 +33,7 @@ function Shortcut({ label, keyHint }: ShortcutProps): JSX.Element {
 interface ShiftOverlayProps {
 	visible: boolean;
 	actions: CmdAction[];
-	userRole: ROLES;
+	userRole: UserRole;
 }
 
 export function ShiftOverlay({

frontend/src/components/cmdKPalette/cmdKPalette.tsx

@@ -11,7 +11,6 @@ import {
 import logEvent from 'api/common/logEvent';
 import { useThemeMode } from 'hooks/useDarkMode';
 import history from 'lib/history';
-import { ROLES as UserRole } from 'types/roles';
 
 import { createShortcutActions } from '../../constants/shortcutActions';
 import { useCmdK } from '../../providers/cmdKProvider';
@@ -29,6 +28,7 @@ type CmdAction = {
 	perform: () => void;
 };
 
+type UserRole = 'ADMIN' | 'EDITOR' | 'AUTHOR' | 'VIEWER';
 export function CmdKPalette({
 	userRole,
 }: {

frontend/src/constants/shortcutActions.tsx

@@ -18,7 +18,8 @@ import {
 	TowerControl,
 	Workflow,
 } from 'lucide-react';
-import { ROLES } from 'types/roles';
+
+export type UserRole = 'ADMIN' | 'EDITOR' | 'AUTHOR' | 'VIEWER';
 
 export type CmdAction = {
 	id: string;
@@ -27,7 +28,7 @@ export type CmdAction = {
 	keywords?: string;
 	section?: string;
 	icon?: React.ReactNode;
-	roles?: ROLES[];
+	roles?: UserRole[];
 	perform: () => void;
 };
 

frontend/src/container/DashboardContainer/visualization/charts/ChartWrapper/ChartWrapper.tsx

@@ -5,7 +5,7 @@ import {
 	LegendPosition,
 	TooltipRenderArgs,
 } from 'lib/uPlotV2/components/types';
-import UPlotChart from 'lib/uPlotV2/components/UPlotChart/UPlotChart';
+import UPlotChart from 'lib/uPlotV2/components/UPlotChart';
 import { PlotContextProvider } from 'lib/uPlotV2/context/PlotContext';
 import TooltipPlugin from 'lib/uPlotV2/plugins/TooltipPlugin/TooltipPlugin';
 import noop from 'lodash-es/noop';

frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/utils.ts

@@ -123,7 +123,7 @@ export const prepareUPlotConfig = ({
 			drawStyle: hasSingleValidPoint ? DrawStyle.Points : DrawStyle.Line,
 			label: label,
 			colorMapping: widget.customLegendColors ?? {},
-			spanGaps: widget.spanGaps ?? true,
+			spanGaps: true,
 			lineStyle: widget.lineStyle || LineStyle.Solid,
 			lineInterpolation: widget.lineInterpolation || LineInterpolation.Spline,
 			showPoints:

frontend/src/container/MembersSettings/MembersSettings.tsx

@@ -6,7 +6,6 @@ import { Check, ChevronDown, Plus } from '@signozhq/icons';
 import { Input } from '@signozhq/input';
 import type { MenuProps } from 'antd';
 import { Dropdown } from 'antd';
-import getPendingInvites from 'api/v1/invite/get';
 import getAll from 'api/v1/user/get';
 import EditMemberDrawer from 'components/EditMemberDrawer/EditMemberDrawer';
 import InviteMembersModal from 'components/InviteMembersModal/InviteMembersModal';
@@ -14,7 +13,7 @@ import MembersTable, { MemberRow } from 'components/MembersTable/MembersTable';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { useAppContext } from 'providers/App/App';
 
-import { FilterMode, INVITE_PREFIX, MemberStatus } from './utils';
+import { FilterMode, MemberStatus, toMemberStatus } from './utils';
 
 import './MembersSettings.styles.scss';
 
@@ -34,51 +33,24 @@ function MembersSettings(): JSX.Element {
 	const [isInviteModalOpen, setIsInviteModalOpen] = useState(false);
 	const [selectedMember, setSelectedMember] = useState<MemberRow | null>(null);
 
-	const {
-		data: usersData,
-		isLoading: isUsersLoading,
-		refetch: refetchUsers,
-	} = useQuery({
+	const { data: usersData, isLoading, refetch: refetchUsers } = useQuery({
 		queryFn: getAll,
 		queryKey: ['getOrgUser', org?.[0]?.id],
 	});
 
-	const {
-		data: invitesData,
-		isLoading: isInvitesLoading,
-		refetch: refetchInvites,
-	} = useQuery({
-		queryFn: getPendingInvites,
-		queryKey: ['getPendingInvites'],
-	});
-
-	const isLoading = isUsersLoading || isInvitesLoading;
-
-	const allMembers = useMemo((): MemberRow[] => {
-		const activeMembers: MemberRow[] = (usersData?.data ?? []).map((user) => ({
-			id: user.id,
-			name: user.displayName,
-			email: user.email,
-			role: user.role,
-			status: MemberStatus.Active,
-			joinedOn: user.createdAt ? String(user.createdAt) : null,
-			updatedAt: user?.updatedAt ? String(user.updatedAt) : null,
-		}));
-
-		const pendingInvites: MemberRow[] = (invitesData?.data ?? []).map(
-			(invite) => ({
-				id: `${INVITE_PREFIX}${invite.id}`,
-				name: invite.name ?? '',
-				email: invite.email,
-				role: invite.role,
-				status: MemberStatus.Invited,
-				joinedOn: invite.createdAt ? String(invite.createdAt) : null,
-				token: invite.token ?? null,
-			}),
-		);
-
-		return [...activeMembers, ...pendingInvites];
-	}, [usersData, invitesData]);
+	const allMembers = useMemo(
+		(): MemberRow[] =>
+			(usersData?.data ?? []).map((user) => ({
+				id: user.id,
+				name: user.displayName,
+				email: user.email,
+				role: user.role,
+				status: toMemberStatus(user.status ?? ''),
+				joinedOn: user.createdAt ? String(user.createdAt) : null,
+				updatedAt: user.updatedAt ? String(user.updatedAt) : null,
+			})),
+		[usersData],
+	);
 
 	const filteredMembers = useMemo((): MemberRow[] => {
 		let result = allMembers;
@@ -100,11 +72,6 @@ function MembersSettings(): JSX.Element {
 		return result;
 	}, [allMembers, filterMode, searchQuery]);
 
-	const paginatedMembers = useMemo((): MemberRow[] => {
-		const start = (currentPage - 1) * PAGE_SIZE;
-		return filteredMembers.slice(start, start + PAGE_SIZE);
-	}, [filteredMembers, currentPage]);
-
 	// TODO(nuqs): Replace with nuqs once the nuqs setup and integration is done
 	const setPage = useCallback(
 		(page: number): void => {
@@ -124,7 +91,9 @@ function MembersSettings(): JSX.Element {
 		}
 	}, [filteredMembers.length, currentPage, setPage]);
 
-	const pendingCount = invitesData?.data?.length ?? 0;
+	const pendingCount = allMembers.filter(
+		(m) => m.status === MemberStatus.Invited,
+	).length;
 	const totalCount = allMembers.length;
 
 	const filterMenuItems: MenuProps['items'] = [
@@ -163,8 +132,7 @@ function MembersSettings(): JSX.Element {
 
 	const handleInviteComplete = useCallback((): void => {
 		refetchUsers();
-		refetchInvites();
-	}, [refetchUsers, refetchInvites]);
+	}, [refetchUsers]);
 
 	const handleRowClick = useCallback((member: MemberRow): void => {
 		setSelectedMember(member);
@@ -176,9 +144,8 @@ function MembersSettings(): JSX.Element {
 
 	const handleMemberEditComplete = useCallback((): void => {
 		refetchUsers();
-		refetchInvites();
 		setSelectedMember(null);
-	}, [refetchUsers, refetchInvites]);
+	}, [refetchUsers]);
 
 	return (
 		<>
@@ -232,7 +199,7 @@ function MembersSettings(): JSX.Element {
 				</div>
 			</div>
 			<MembersTable
-				data={paginatedMembers}
+				data={filteredMembers}
 				loading={isLoading}
 				total={filteredMembers.length}
 				currentPage={currentPage}
@@ -253,7 +220,6 @@ function MembersSettings(): JSX.Element {
 				open={selectedMember !== null}
 				onClose={handleDrawerClose}
 				onComplete={handleMemberEditComplete}
-				onRefetch={handleInviteComplete}
 			/>
 		</>
 	);

frontend/src/container/MembersSettings/__tests__/MembersSettings.integration.test.tsx

@@ -1,6 +1,5 @@
 import { rest, server } from 'mocks-server/server';
 import { render, screen, userEvent } from 'tests/test-utils';
-import { PendingInvite } from 'types/api/user/getPendingInvites';
 import { UserResponse } from 'types/api/user/getUser';
 
 import MembersSettings from '../MembersSettings';
@@ -13,7 +12,6 @@ jest.mock('@signozhq/sonner', () => ({
 }));
 
 const USERS_ENDPOINT = '*/api/v1/user';
-const INVITES_ENDPOINT = '*/api/v1/invite';
 
 const mockUsers: UserResponse[] = [
 	{
@@ -21,7 +19,8 @@ const mockUsers: UserResponse[] = [
 		displayName: 'Alice Smith',
 		email: 'alice@signoz.io',
 		role: 'ADMIN',
-		createdAt: 1700000000,
+		status: 'active',
+		createdAt: '2024-01-01T00:00:00.000Z',
 		organization: 'TestOrg',
 		orgId: 'org-1',
 	},
@@ -30,20 +29,30 @@ const mockUsers: UserResponse[] = [
 		displayName: 'Bob Jones',
 		email: 'bob@signoz.io',
 		role: 'VIEWER',
-		createdAt: 1700000001,
+		status: 'active',
+		createdAt: '2024-01-02T00:00:00.000Z',
 		organization: 'TestOrg',
 		orgId: 'org-1',
 	},
-];
-
-const mockInvites: PendingInvite[] = [
 	{
 		id: 'inv-1',
+		displayName: '',
 		email: 'charlie@signoz.io',
-		name: 'Charlie',
 		role: 'EDITOR',
-		createdAt: 1700000002,
-		token: 'tok-abc',
+		status: 'pending_invite',
+		createdAt: '2024-01-03T00:00:00.000Z',
+		organization: 'TestOrg',
+		orgId: 'org-1',
+	},
+	{
+		id: 'user-3',
+		displayName: 'Dave Deleted',
+		email: 'dave@signoz.io',
+		role: 'VIEWER',
+		status: 'deleted',
+		createdAt: '2024-01-04T00:00:00.000Z',
+		organization: 'TestOrg',
+		orgId: 'org-1',
 	},
 ];
 
@@ -54,9 +63,6 @@ describe('MembersSettings (integration)', () => {
 			rest.get(USERS_ENDPOINT, (_, res, ctx) =>
 				res(ctx.status(200), ctx.json({ data: mockUsers })),
 			),
-			rest.get(INVITES_ENDPOINT, (_, res, ctx) =>
-				res(ctx.status(200), ctx.json({ data: mockInvites })),
-			),
 		);
 	});
 
@@ -64,14 +70,16 @@ describe('MembersSettings (integration)', () => {
 		server.resetHandlers();
 	});
 
-	it('loads and displays active users and pending invites', async () => {
+	it('loads and displays active users, pending invites, and deleted members', async () => {
 		render(<MembersSettings />);
 
 		await screen.findByText('Alice Smith');
 		expect(screen.getByText('Bob Jones')).toBeInTheDocument();
 		expect(screen.getByText('charlie@signoz.io')).toBeInTheDocument();
+		expect(screen.getByText('Dave Deleted')).toBeInTheDocument();
 		expect(screen.getAllByText('ACTIVE')).toHaveLength(2);
 		expect(screen.getByText('INVITED')).toBeInTheDocument();
+		expect(screen.getByText('DELETED')).toBeInTheDocument();
 	});
 
 	it('filters to pending invites via the filter dropdown', async () => {
@@ -107,7 +115,7 @@ describe('MembersSettings (integration)', () => {
 		expect(screen.queryByText('charlie@signoz.io')).not.toBeInTheDocument();
 	});
 
-	it('opens EditMemberDrawer when a member row is clicked', async () => {
+	it('opens EditMemberDrawer when an active member row is clicked', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 
 		render(<MembersSettings />);
@@ -117,6 +125,16 @@ describe('MembersSettings (integration)', () => {
 		await screen.findByText('Member Details');
 	});
 
+	it('does not open EditMemberDrawer when a deleted member row is clicked', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+		render(<MembersSettings />);
+
+		await user.click(await screen.findByText('Dave Deleted'));
+
+		expect(screen.queryByText('Member Details')).not.toBeInTheDocument();
+	});
+
 	it('opens InviteMembersModal when "Invite member" button is clicked', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 

frontend/src/container/MembersSettings/utils.ts

@@ -1,5 +1,3 @@
-export const INVITE_PREFIX = 'invite-';
-
 export enum FilterMode {
 	All = 'all',
 	Invited = 'invited',
@@ -8,4 +6,25 @@ export enum FilterMode {
 export enum MemberStatus {
 	Active = 'Active',
 	Invited = 'Invited',
+	Deleted = 'Deleted',
+	Anonymous = 'Anonymous',
+}
+
+export enum UserApiStatus {
+	Active = 'active',
+	PendingInvite = 'pending_invite',
+	Deleted = 'deleted',
+}
+
+export function toMemberStatus(apiStatus: string): MemberStatus {
+	switch (apiStatus) {
+		case UserApiStatus.PendingInvite:
+			return MemberStatus.Invited;
+		case UserApiStatus.Deleted:
+			return MemberStatus.Deleted;
+		case UserApiStatus.Active:
+			return MemberStatus.Active;
+		default:
+			return MemberStatus.Anonymous;
+	}
 }

frontend/src/container/NewWidget/RightContainer/FillModeSelector.styles.scss

@@ -0,0 +1,21 @@
+.fill-mode-selector {
+	.fill-mode-icon {
+		width: 24px;
+		height: 24px;
+	}
+
+	.fill-mode-label {
+		text-transform: uppercase;
+		font-size: 12px;
+		font-weight: 500;
+		color: var(--bg-vanilla-400);
+	}
+}
+
+.lightMode {
+	.fill-mode-selector {
+		.fill-mode-label {
+			color: var(--bg-ink-400);
+		}
+	}
+}

frontend/src/container/NewWidget/RightContainer/FillModeSelector.tsx

@@ -0,0 +1,94 @@
+import { ToggleGroup, ToggleGroupItem } from '@signozhq/toggle-group';
+import { Typography } from 'antd';
+import { FillMode } from 'lib/uPlotV2/config/types';
+
+import './FillModeSelector.styles.scss';
+
+interface FillModeSelectorProps {
+	value: FillMode;
+	onChange: (value: FillMode) => void;
+}
+
+export function FillModeSelector({
+	value,
+	onChange,
+}: FillModeSelectorProps): JSX.Element {
+	return (
+		<section className="fill-mode-selector control-container">
+			<Typography.Text className="section-heading">Fill mode</Typography.Text>
+			<ToggleGroup
+				type="single"
+				value={value}
+				variant="outline"
+				size="lg"
+				onValueChange={(newValue): void => {
+					if (newValue) {
+						onChange(newValue as FillMode);
+					}
+				}}
+			>
+				<ToggleGroupItem value={FillMode.None} aria-label="None" title="None">
+					<svg
+						className="fill-mode-icon"
+						viewBox="0 0 48 48"
+						fill="none"
+						stroke="#888"
+						strokeWidth="2"
+						strokeLinecap="round"
+						strokeLinejoin="round"
+					>
+						<rect x="8" y="16" width="32" height="16" stroke="#888" fill="none" />
+					</svg>
+					<Typography.Text className="section-heading-small">None</Typography.Text>
+				</ToggleGroupItem>
+				<ToggleGroupItem value={FillMode.Solid} aria-label="Solid" title="Solid">
+					<svg
+						className="fill-mode-icon"
+						viewBox="0 0 48 48"
+						fill="none"
+						stroke="#888"
+						strokeWidth="2"
+						strokeLinecap="round"
+						strokeLinejoin="round"
+					>
+						<rect x="8" y="16" width="32" height="16" fill="#888" />
+					</svg>
+					<Typography.Text className="section-heading-small">Solid</Typography.Text>
+				</ToggleGroupItem>
+				<ToggleGroupItem
+					value={FillMode.Gradient}
+					aria-label="Gradient"
+					title="Gradient"
+				>
+					<svg
+						className="fill-mode-icon"
+						viewBox="0 0 48 48"
+						fill="none"
+						stroke="#888"
+						strokeWidth="2"
+						strokeLinecap="round"
+						strokeLinejoin="round"
+					>
+						<defs>
+							<linearGradient id="fill-gradient" x1="0" y1="0" x2="1" y2="0">
+								<stop offset="0%" stopColor="#888" stopOpacity="0.2" />
+								<stop offset="100%" stopColor="#888" stopOpacity="0.8" />
+							</linearGradient>
+						</defs>
+						<rect
+							x="8"
+							y="16"
+							width="32"
+							height="16"
+							fill="url(#fill-gradient)"
+							stroke="#888"
+						/>
+					</svg>
+					<Typography.Text className="section-heading-small">
+						Gradient
+					</Typography.Text>
+				</ToggleGroupItem>
+			</ToggleGroup>
+		</section>
+	);
+}

frontend/src/container/NewWidget/RightContainer/LineInterpolationSelector.styles.scss

@@ -0,0 +1,21 @@
+.line-interpolation-selector {
+	.line-interpolation-icon {
+		width: 24px;
+		height: 24px;
+	}
+
+	.line-interpolation-label {
+		text-transform: uppercase;
+		font-size: 12px;
+		font-weight: 500;
+		color: var(--bg-vanilla-400);
+	}
+}
+
+.lightMode {
+	.line-interpolation-selector {
+		.line-interpolation-label {
+			color: var(--bg-ink-400);
+		}
+	}
+}

frontend/src/container/NewWidget/RightContainer/LineInterpolationSelector.tsx

@@ -0,0 +1,110 @@
+import { ToggleGroup, ToggleGroupItem } from '@signozhq/toggle-group';
+import { Typography } from 'antd';
+import { LineInterpolation } from 'lib/uPlotV2/config/types';
+
+import './LineInterpolationSelector.styles.scss';
+
+interface LineInterpolationSelectorProps {
+	value: LineInterpolation;
+	onChange: (value: LineInterpolation) => void;
+}
+
+export function LineInterpolationSelector({
+	value,
+	onChange,
+}: LineInterpolationSelectorProps): JSX.Element {
+	return (
+		<section className="line-interpolation-selector control-container">
+			<Typography.Text className="section-heading">
+				Line interpolation
+			</Typography.Text>
+			<ToggleGroup
+				type="single"
+				value={value}
+				variant="outline"
+				size="lg"
+				onValueChange={(newValue): void => {
+					if (newValue) {
+						onChange(newValue as LineInterpolation);
+					}
+				}}
+			>
+				<ToggleGroupItem
+					value={LineInterpolation.Linear}
+					aria-label="Linear"
+					title="Linear"
+				>
+					<svg
+						className="line-interpolation-icon"
+						viewBox="0 0 48 48"
+						fill="none"
+						stroke="#888"
+						strokeWidth="2"
+						strokeLinecap="round"
+						strokeLinejoin="round"
+					>
+						<circle cx="8" cy="32" r="3" fill="#888" />
+						<circle cx="24" cy="16" r="3" fill="#888" />
+						<circle cx="40" cy="32" r="3" fill="#888" />
+						<path d="M8 32 L24 16 L40 32" stroke="#888" />
+					</svg>
+				</ToggleGroupItem>
+				<ToggleGroupItem value={LineInterpolation.Spline} aria-label="Spline">
+					<svg
+						className="line-interpolation-icon"
+						viewBox="0 0 48 48"
+						fill="none"
+						stroke="#888"
+						strokeWidth="2"
+						strokeLinecap="round"
+						strokeLinejoin="round"
+					>
+						<circle cx="8" cy="32" r="3" fill="#888" />
+						<circle cx="24" cy="16" r="3" fill="#888" />
+						<circle cx="40" cy="32" r="3" fill="#888" />
+						<path d="M8 32 C16 8, 32 8, 40 32" />
+					</svg>
+				</ToggleGroupItem>
+				<ToggleGroupItem
+					value={LineInterpolation.StepAfter}
+					aria-label="Step After"
+				>
+					<svg
+						className="line-interpolation-icon"
+						viewBox="0 0 48 48"
+						fill="none"
+						stroke="#888"
+						strokeWidth="2"
+						strokeLinecap="round"
+						strokeLinejoin="round"
+					>
+						<circle cx="8" cy="32" r="3" fill="#888" />
+						<circle cx="24" cy="16" r="3" fill="#888" />
+						<circle cx="40" cy="32" r="3" fill="#888" />
+						<path d="M8 32 V16 H24 V32 H40" />
+					</svg>
+				</ToggleGroupItem>
+
+				<ToggleGroupItem
+					value={LineInterpolation.StepBefore}
+					aria-label="Step Before"
+				>
+					<svg
+						className="line-interpolation-icon"
+						viewBox="0 0 48 48"
+						fill="none"
+						stroke="#888"
+						strokeWidth="2"
+						strokeLinecap="round"
+						strokeLinejoin="round"
+					>
+						<circle cx="8" cy="32" r="3" fill="#888" />
+						<circle cx="24" cy="16" r="3" fill="#888" />
+						<circle cx="40" cy="32" r="3" fill="#888" />
+						<path d="M8 32 H24 V16 H40 V32" />
+					</svg>
+				</ToggleGroupItem>
+			</ToggleGroup>
+		</section>
+	);
+}

frontend/src/container/NewWidget/RightContainer/LineStyleSelector.styles.scss

@@ -0,0 +1,21 @@
+.line-style-selector {
+	.line-style-icon {
+		width: 24px;
+		height: 24px;
+	}
+
+	.line-style-label {
+		text-transform: uppercase;
+		font-size: 12px;
+		font-weight: 500;
+		color: var(--bg-vanilla-400);
+	}
+}
+
+.lightMode {
+	.line-style-selector {
+		.line-style-label {
+			color: var(--bg-ink-400);
+		}
+	}
+}

frontend/src/container/NewWidget/RightContainer/LineStyleSelector.tsx

@@ -0,0 +1,66 @@
+import { ToggleGroup, ToggleGroupItem } from '@signozhq/toggle-group';
+import { Typography } from 'antd';
+import { LineStyle } from 'lib/uPlotV2/config/types';
+
+import './LineStyleSelector.styles.scss';
+
+interface LineStyleSelectorProps {
+	value: LineStyle;
+	onChange: (value: LineStyle) => void;
+}
+
+export function LineStyleSelector({
+	value,
+	onChange,
+}: LineStyleSelectorProps): JSX.Element {
+	return (
+		<section className="line-style-selector control-container">
+			<Typography.Text className="section-heading">Line style</Typography.Text>
+			<ToggleGroup
+				type="single"
+				value={value}
+				variant="outline"
+				size="lg"
+				onValueChange={(newValue): void => {
+					if (newValue) {
+						onChange(newValue as LineStyle);
+					}
+				}}
+			>
+				<ToggleGroupItem value={LineStyle.Solid} aria-label="Solid" title="Solid">
+					<svg
+						className="line-style-icon"
+						viewBox="0 0 48 48"
+						fill="none"
+						stroke="#888"
+						strokeWidth="2"
+						strokeLinecap="round"
+						strokeLinejoin="round"
+					>
+						<path d="M8 24 L40 24" />
+					</svg>
+					<Typography.Text className="section-heading-small">Solid</Typography.Text>
+				</ToggleGroupItem>
+				<ToggleGroupItem
+					value={LineStyle.Dashed}
+					aria-label="Dashed"
+					title="Dashed"
+				>
+					<svg
+						className="line-style-icon"
+						viewBox="0 0 48 48"
+						fill="none"
+						stroke="#888"
+						strokeWidth="2"
+						strokeLinecap="round"
+						strokeLinejoin="round"
+						strokeDasharray="6 4"
+					>
+						<path d="M8 24 L40 24" />
+					</svg>
+					<Typography.Text className="section-heading-small">Dashed</Typography.Text>
+				</ToggleGroupItem>
+			</ToggleGroup>
+		</section>
+	);
+}

frontend/src/container/NewWidget/RightContainer/RightContainer.styles.scss

@@ -4,10 +4,6 @@
 	font-family: 'Space Mono';
 	padding-bottom: 48px;
 
-	.panel-type-select {
-		width: 100%;
-	}
-
 	.section-heading {
 		font-family: 'Space Mono';
 		color: var(--bg-vanilla-400);
@@ -30,6 +26,10 @@
 		letter-spacing: 0.48px;
 	}
 
+	.panel-type-select {
+		width: 100%;
+	}
+
 	.header {
 		display: flex;
 		padding: 14px 14px 14px 12px;
@@ -192,16 +192,6 @@
 			justify-content: space-between;
 		}
 	}
-
-	.context-links {
-		padding: 12px 12px 16px 12px;
-		border-bottom: 1px solid var(--bg-slate-500);
-	}
-
-	.thresholds-section {
-		padding: 12px 12px 16px 12px;
-		border-top: 1px solid var(--bg-slate-500);
-	}
 }
 
 .select-option {
@@ -226,8 +216,7 @@
 .lightMode {
 	.right-container {
 		background-color: var(--bg-vanilla-100);
-		.section-heading,
-		.section-heading-small {
+		.section-heading {
 			color: var(--bg-ink-400);
 		}
 		.header {

frontend/src/container/NewWidget/RightContainer/SettingSections/ChartAppearanceSection/ChartAppearanceSection.tsx

@@ -7,10 +7,9 @@ import {
 } from 'lib/uPlotV2/config/types';
 import { Paintbrush } from 'lucide-react';
 
-import DisconnectValuesSelector from '../../components/DisconnectValuesSelector/DisconnectValuesSelector';
-import FillModeSelector from '../../components/FillModeSelector/FillModeSelector';
-import LineInterpolationSelector from '../../components/LineInterpolationSelector/LineInterpolationSelector';
-import LineStyleSelector from '../../components/LineStyleSelector/LineStyleSelector';
+import { FillModeSelector } from '../../components/FillModeSelector/FillModeSelector';
+import { LineInterpolationSelector } from '../../components/LineInterpolationSelector/LineInterpolationSelector';
+import { LineStyleSelector } from '../../components/LineStyleSelector/LineStyleSelector';
 import SettingsSection from '../../components/SettingsSection/SettingsSection';
 
 interface ChartAppearanceSectionProps {
@@ -22,14 +21,10 @@ interface ChartAppearanceSectionProps {
 	setLineInterpolation: Dispatch<SetStateAction<LineInterpolation>>;
 	showPoints: boolean;
 	setShowPoints: Dispatch<SetStateAction<boolean>>;
-	spanGaps: boolean | number;
-	setSpanGaps: Dispatch<SetStateAction<boolean | number>>;
 	allowFillMode: boolean;
 	allowLineStyle: boolean;
 	allowLineInterpolation: boolean;
 	allowShowPoints: boolean;
-	allowSpanGaps: boolean;
-	stepInterval: number;
 }
 
 export default function ChartAppearanceSection({
@@ -41,14 +36,10 @@ export default function ChartAppearanceSection({
 	setLineInterpolation,
 	showPoints,
 	setShowPoints,
-	spanGaps,
-	setSpanGaps,
 	allowFillMode,
 	allowLineStyle,
 	allowLineInterpolation,
 	allowShowPoints,
-	allowSpanGaps,
-	stepInterval,
 }: ChartAppearanceSectionProps): JSX.Element {
 	return (
 		<SettingsSection title="Chart Appearance" icon={<Paintbrush size={14} />}>
@@ -75,13 +66,6 @@ export default function ChartAppearanceSection({
 					<Switch size="small" checked={showPoints} onChange={setShowPoints} />
 				</section>
 			)}
-			{allowSpanGaps && (
-				<DisconnectValuesSelector
-					value={spanGaps}
-					minValue={stepInterval}
-					onChange={setSpanGaps}
-				/>
-			)}
 		</SettingsSection>
 	);
 }

frontend/src/container/NewWidget/RightContainer/__tests__/RightContainer.test.tsx

@@ -178,8 +178,6 @@ describe('RightContainer - Alerts Section', () => {
 		setLineStyle: jest.fn(),
 		showPoints: false,
 		setShowPoints: jest.fn(),
-		spanGaps: false,
-		setSpanGaps: jest.fn(),
 	};
 
 	beforeEach(() => {

frontend/src/container/NewWidget/RightContainer/components/DisconnectValuesSelector/DisconnectValuesModeToggle.tsx

@@ -1,38 +0,0 @@
-import { ToggleGroup, ToggleGroupItem } from '@signozhq/toggle-group';
-import { Typography } from 'antd';
-import { DisconnectedValuesMode } from 'lib/uPlotV2/config/types';
-
-interface DisconnectValuesModeToggleProps {
-	value: DisconnectedValuesMode;
-	onChange: (value: DisconnectedValuesMode) => void;
-}
-
-export default function DisconnectValuesModeToggle({
-	value,
-	onChange,
-}: DisconnectValuesModeToggleProps): JSX.Element {
-	return (
-		<ToggleGroup
-			type="single"
-			value={value}
-			size="lg"
-			onValueChange={(newValue): void => {
-				if (newValue) {
-					onChange(newValue as DisconnectedValuesMode);
-				}
-			}}
-		>
-			<ToggleGroupItem value={DisconnectedValuesMode.Never} aria-label="Never">
-				<Typography.Text className="section-heading-small">Never</Typography.Text>
-			</ToggleGroupItem>
-			<ToggleGroupItem
-				value={DisconnectedValuesMode.Threshold}
-				aria-label="Threshold"
-			>
-				<Typography.Text className="section-heading-small">
-					Threshold
-				</Typography.Text>
-			</ToggleGroupItem>
-		</ToggleGroup>
-	);
-}

frontend/src/container/NewWidget/RightContainer/components/DisconnectValuesSelector/DisconnectValuesSelector.styles.scss

@@ -1,21 +0,0 @@
-.disconnect-values-selector {
-	.disconnect-values-input-wrapper {
-		display: flex;
-		flex-direction: column;
-		gap: 16px;
-
-		.disconnect-values-threshold-wrapper {
-			display: flex;
-			flex-direction: column;
-			gap: 8px;
-			.disconnect-values-threshold-input {
-				max-width: 160px;
-				height: auto;
-				.disconnect-values-threshold-prefix {
-					padding: 0 8px;
-					font-size: 20px;
-				}
-			}
-		}
-	}
-}

frontend/src/container/NewWidget/RightContainer/components/DisconnectValuesSelector/DisconnectValuesSelector.tsx

@@ -1,91 +0,0 @@
-import { useEffect, useState } from 'react';
-import { Typography } from 'antd';
-import { DisconnectedValuesMode } from 'lib/uPlotV2/config/types';
-
-import DisconnectValuesModeToggle from './DisconnectValuesModeToggle';
-import DisconnectValuesThresholdInput from './DisconnectValuesThresholdInput';
-
-import './DisconnectValuesSelector.styles.scss';
-
-const DEFAULT_THRESHOLD_SECONDS = 60;
-
-interface DisconnectValuesSelectorProps {
-	value: boolean | number;
-	minValue: number;
-	onChange: (value: boolean | number) => void;
-}
-
-export default function DisconnectValuesSelector({
-	value,
-	minValue,
-	onChange,
-}: DisconnectValuesSelectorProps): JSX.Element {
-	const [mode, setMode] = useState<DisconnectedValuesMode>(() => {
-		if (typeof value === 'number') {
-			return DisconnectedValuesMode.Threshold;
-		}
-		return DisconnectedValuesMode.Never;
-	});
-	const [thresholdSeconds, setThresholdSeconds] = useState<number>(
-		typeof value === 'number' ? value : minValue ?? DEFAULT_THRESHOLD_SECONDS,
-	);
-
-	useEffect(() => {
-		if (typeof value === 'boolean') {
-			setMode(DisconnectedValuesMode.Never);
-		} else if (typeof value === 'number') {
-			setMode(DisconnectedValuesMode.Threshold);
-			setThresholdSeconds(value);
-		}
-	}, [value]);
-
-	useEffect(() => {
-		if (minValue !== undefined) {
-			setThresholdSeconds(minValue);
-			if (mode === DisconnectedValuesMode.Threshold) {
-				onChange(minValue);
-			}
-		}
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [minValue]);
-
-	const handleModeChange = (newMode: DisconnectedValuesMode): void => {
-		setMode(newMode);
-		switch (newMode) {
-			case DisconnectedValuesMode.Never:
-				onChange(true);
-				break;
-			case DisconnectedValuesMode.Threshold:
-				onChange(thresholdSeconds);
-				break;
-		}
-	};
-
-	const handleThresholdChange = (seconds: number): void => {
-		setThresholdSeconds(seconds);
-		onChange(seconds);
-	};
-
-	return (
-		<section className="disconnect-values-selector control-container">
-			<Typography.Text className="section-heading">
-				Disconnect values
-			</Typography.Text>
-			<div className="disconnect-values-input-wrapper">
-				<DisconnectValuesModeToggle value={mode} onChange={handleModeChange} />
-				{mode === DisconnectedValuesMode.Threshold && (
-					<section className="control-container">
-						<Typography.Text className="section-heading">
-							Threshold Value
-						</Typography.Text>
-						<DisconnectValuesThresholdInput
-							value={thresholdSeconds}
-							minValue={minValue}
-							onChange={handleThresholdChange}
-						/>
-					</section>
-				)}
-			</div>
-		</section>
-	);
-}

frontend/src/container/NewWidget/RightContainer/components/DisconnectValuesSelector/DisconnectValuesThresholdInput.tsx

@@ -1,92 +0,0 @@
-import { ChangeEvent, useEffect, useState } from 'react';
-import { rangeUtil } from '@grafana/data';
-import { Callout, Input } from '@signozhq/ui';
-interface DisconnectValuesThresholdInputProps {
-	value: number;
-	onChange: (seconds: number) => void;
-	minValue: number;
-}
-
-export default function DisconnectValuesThresholdInput({
-	value,
-	onChange,
-	minValue,
-}: DisconnectValuesThresholdInputProps): JSX.Element {
-	const [inputValue, setInputValue] = useState<string>(
-		rangeUtil.secondsToHms(value),
-	);
-	const [error, setError] = useState<string | null>(null);
-
-	useEffect(() => {
-		setInputValue(rangeUtil.secondsToHms(value));
-		setError(null);
-	}, [value]);
-
-	const updateValue = (txt: string): void => {
-		if (!txt) {
-			return;
-		}
-		try {
-			let seconds: number;
-			if (rangeUtil.isValidTimeSpan(txt)) {
-				seconds = rangeUtil.intervalToSeconds(txt);
-			} else {
-				const parsed = Number(txt);
-				if (Number.isNaN(parsed) || parsed <= 0) {
-					setError('Enter a valid duration (e.g. 1h, 10m, 1d)');
-					return;
-				}
-				seconds = parsed;
-			}
-			if (minValue !== undefined && seconds < minValue) {
-				setError(`Threshold should be > ${rangeUtil.secondsToHms(minValue)}`);
-				return;
-			}
-			setError(null);
-			setInputValue(txt);
-			onChange(seconds);
-		} catch {
-			setError('Invalid threshold value');
-		}
-	};
-
-	const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>): void => {
-		if (e.key === 'Enter') {
-			updateValue(e.currentTarget.value);
-		}
-	};
-
-	const handleBlur = (e: React.FocusEvent<HTMLInputElement>): void => {
-		updateValue(e.currentTarget.value);
-	};
-
-	const handleChange = (e: ChangeEvent<HTMLInputElement>): void => {
-		setInputValue(e.currentTarget.value);
-		if (error) {
-			setError(null);
-		}
-	};
-
-	return (
-		<div className="disconnect-values-threshold-wrapper">
-			<Input
-				name="disconnect-values-threshold"
-				type="text"
-				className="disconnect-values-threshold-input"
-				prefix={<span className="disconnect-values-threshold-prefix">&gt;</span>}
-				value={inputValue}
-				onChange={handleChange}
-				onKeyDown={handleKeyDown}
-				onBlur={handleBlur}
-				autoFocus={true}
-				aria-invalid={!!error}
-				aria-describedby={error ? 'threshold-error' : undefined}
-			/>
-			{error && (
-				<Callout type="error" size="small" showIcon>
-					{error}
-				</Callout>
-			)}
-		</div>
-	);
-}

frontend/src/container/NewWidget/RightContainer/components/FillModeSelector/FillModeSelector.tsx

@@ -9,7 +9,7 @@ interface FillModeSelectorProps {
 	onChange: (value: FillMode) => void;
 }
 
-export default function FillModeSelector({
+export function FillModeSelector({
 	value,
 	onChange,
 }: FillModeSelectorProps): JSX.Element {

frontend/src/container/NewWidget/RightContainer/components/LineInterpolationSelector/LineInterpolationSelector.tsx

@@ -9,7 +9,7 @@ interface LineInterpolationSelectorProps {
 	onChange: (value: LineInterpolation) => void;
 }
 
-export default function LineInterpolationSelector({
+export function LineInterpolationSelector({
 	value,
 	onChange,
 }: LineInterpolationSelectorProps): JSX.Element {

frontend/src/container/NewWidget/RightContainer/components/LineStyleSelector/LineStyleSelector.tsx

@@ -9,7 +9,7 @@ interface LineStyleSelectorProps {
 	onChange: (value: LineStyle) => void;
 }
 
-export default function LineStyleSelector({
+export function LineStyleSelector({
 	value,
 	onChange,
 }: LineStyleSelectorProps): JSX.Element {

frontend/src/container/NewWidget/RightContainer/constants.ts

@@ -262,17 +262,3 @@ export const panelTypeVsShowPoints: {
 	[PANEL_TYPES.TRACE]: false,
 	[PANEL_TYPES.EMPTY_WIDGET]: false,
 } as const;
-
-export const panelTypeVsSpanGaps: {
-	[key in PANEL_TYPES]: boolean;
-} = {
-	[PANEL_TYPES.TIME_SERIES]: true,
-	[PANEL_TYPES.VALUE]: false,
-	[PANEL_TYPES.TABLE]: false,
-	[PANEL_TYPES.LIST]: false,
-	[PANEL_TYPES.PIE]: false,
-	[PANEL_TYPES.BAR]: false,
-	[PANEL_TYPES.HISTOGRAM]: false,
-	[PANEL_TYPES.TRACE]: false,
-	[PANEL_TYPES.EMPTY_WIDGET]: false,
-} as const;

frontend/src/container/NewWidget/RightContainer/index.tsx

@@ -1,7 +1,6 @@
 import { Dispatch, SetStateAction, useMemo } from 'react';
 import { UseQueryResult } from 'react-query';
 import { Typography } from 'antd';
-import { ExecStats } from 'api/v5/v5';
 import { PrecisionOption, PrecisionOptionsEnum } from 'components/Graph/types';
 import { PANEL_TYPES, PanelDisplay } from 'constants/queryBuilder';
 import { PanelTypesWithData } from 'container/DashboardContainer/PanelTypeSelectionModal/menuItems';
@@ -12,7 +11,6 @@ import {
 	LineInterpolation,
 	LineStyle,
 } from 'lib/uPlotV2/config/types';
-import get from 'lodash-es/get';
 import { SuccessResponse } from 'types/api';
 import {
 	ColumnUnit,
@@ -38,7 +36,6 @@ import {
 	panelTypeVsPanelTimePreferences,
 	panelTypeVsShowPoints,
 	panelTypeVsSoftMinMax,
-	panelTypeVsSpanGaps,
 	panelTypeVsStackingChartPreferences,
 	panelTypeVsThreshold,
 	panelTypeVsYAxisUnit,
@@ -71,8 +68,6 @@ function RightContainer({
 	setLineStyle,
 	showPoints,
 	setShowPoints,
-	spanGaps,
-	setSpanGaps,
 	bucketCount,
 	bucketWidth,
 	stackedBarChart,
@@ -143,7 +138,6 @@ function RightContainer({
 	const allowLineStyle = panelTypeVsLineStyle[selectedGraph];
 	const allowFillMode = panelTypeVsFillMode[selectedGraph];
 	const allowShowPoints = panelTypeVsShowPoints[selectedGraph];
-	const allowSpanGaps = panelTypeVsSpanGaps[selectedGraph];
 
 	const decimapPrecisionOptions = useMemo(
 		() => [
@@ -182,26 +176,10 @@ function RightContainer({
 			(allowFillMode ||
 				allowLineStyle ||
 				allowLineInterpolation ||
-				allowShowPoints ||
-				allowSpanGaps),
-		[
-			allowFillMode,
-			allowLineStyle,
-			allowLineInterpolation,
-			allowShowPoints,
-			allowSpanGaps,
-		],
+				allowShowPoints),
+		[allowFillMode, allowLineStyle, allowLineInterpolation, allowShowPoints],
 	);
 
-	const stepInterval = useMemo(() => {
-		const stepIntervals: ExecStats['stepIntervals'] = get(
-			queryResponse,
-			'data.payload.data.newResult.meta.stepIntervals',
-			{},
-		);
-		return Math.min(...Object.values(stepIntervals));
-	}, [queryResponse]);
-
 	return (
 		<div className="right-container">
 			<section className="header">
@@ -259,14 +237,10 @@ function RightContainer({
 						setLineInterpolation={setLineInterpolation}
 						showPoints={showPoints}
 						setShowPoints={setShowPoints}
-						spanGaps={spanGaps}
-						setSpanGaps={setSpanGaps}
 						allowFillMode={allowFillMode}
 						allowLineStyle={allowLineStyle}
 						allowLineInterpolation={allowLineInterpolation}
 						allowShowPoints={allowShowPoints}
-						allowSpanGaps={allowSpanGaps}
-						stepInterval={stepInterval}
 					/>
 				)}
 
@@ -390,8 +364,6 @@ export interface RightContainerProps {
 	setLineStyle: Dispatch<SetStateAction<LineStyle>>;
 	showPoints: boolean;
 	setShowPoints: Dispatch<SetStateAction<boolean>>;
-	spanGaps: boolean | number;
-	setSpanGaps: Dispatch<SetStateAction<boolean | number>>;
 }
 
 RightContainer.defaultProps = {

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

@@ -14,6 +14,7 @@ import { DashboardProvider } from 'providers/Dashboard/Dashboard';
 import { PreferenceContextProvider } from 'providers/preferences/context/PreferenceContextProvider';
 import i18n from 'ReactI18';
 import {
+	fireEvent,
 	getByText as getByTextUtil,
 	render,
 	userEvent,
@@ -341,8 +342,9 @@ describe('Stacking bar in new panel', () => {
 const STACKING_STATE_ATTR = 'data-stacking-state';
 
 describe('when switching to BAR panel type', () => {
+	jest.setTimeout(10000);
+
 	beforeEach(() => {
-		jest.useFakeTimers();
 		jest.clearAllMocks();
 
 		// Mock useSearchParams to return the expected values
@@ -352,15 +354,7 @@ describe('when switching to BAR panel type', () => {
 		]);
 	});
 
-	afterEach(() => {
-		jest.useRealTimers();
-	});
-
 	it('should preserve saved stacking value of true', async () => {
-		const user = userEvent.setup({
-			advanceTimers: jest.advanceTimersByTime.bind(jest),
-		});
-
 		const { getByTestId, getByText, container } = render(
 			<DashboardProvider dashboardId="">
 				<NewWidget
@@ -376,7 +370,7 @@ describe('when switching to BAR panel type', () => {
 			'true',
 		);
 
-		await user.click(getByText('Bar')); // Panel Type Selected
+		await userEvent.click(getByText('Bar')); // Panel Type Selected
 
 		// find dropdown with - .ant-select-dropdown
 		const panelDropdown = document.querySelector(
@@ -386,7 +380,7 @@ describe('when switching to BAR panel type', () => {
 
 		// Select TimeSeries from dropdown
 		const option = within(panelDropdown).getByText('Time Series');
-		await user.click(option);
+		fireEvent.click(option);
 
 		expect(getByTestId('panel-change-select')).toHaveAttribute(
 			STACKING_STATE_ATTR,
@@ -401,7 +395,7 @@ describe('when switching to BAR panel type', () => {
 		expect(panelTypeDropdown2).toBeInTheDocument();
 
 		expect(getByTextUtil(panelTypeDropdown2, 'Time Series')).toBeInTheDocument();
-		await user.click(getByTextUtil(panelTypeDropdown2, 'Time Series'));
+		fireEvent.click(getByTextUtil(panelTypeDropdown2, 'Time Series'));
 
 		// find dropdown with - .ant-select-dropdown
 		const panelDropdown2 = document.querySelector(
@@ -409,7 +403,7 @@ describe('when switching to BAR panel type', () => {
 		) as HTMLElement;
 		// // Select BAR from dropdown
 		const BarOption = within(panelDropdown2).getByText('Bar');
-		await user.click(BarOption);
+		fireEvent.click(BarOption);
 
 		// Stack series should be true
 		checkStackSeriesState(container, true);

frontend/src/container/NewWidget/index.tsx

@@ -220,9 +220,6 @@ function NewWidget({
 	const [showPoints, setShowPoints] = useState<boolean>(
 		selectedWidget?.showPoints ?? false,
 	);
-	const [spanGaps, setSpanGaps] = useState<boolean | number>(
-		selectedWidget?.spanGaps ?? true,
-	);
 	const [customLegendColors, setCustomLegendColors] = useState<
 		Record<string, string>
 	>(selectedWidget?.customLegendColors || {});
@@ -292,7 +289,6 @@ function NewWidget({
 				fillMode,
 				lineStyle,
 				showPoints,
-				spanGaps,
 				columnUnits,
 				bucketCount,
 				stackedBarChart,
@@ -332,7 +328,6 @@ function NewWidget({
 		fillMode,
 		lineStyle,
 		showPoints,
-		spanGaps,
 		customLegendColors,
 		contextLinks,
 		selectedWidget.columnWidths,
@@ -546,7 +541,6 @@ function NewWidget({
 								softMin: selectedWidget?.softMin || 0,
 								softMax: selectedWidget?.softMax || 0,
 								fillSpans: selectedWidget?.fillSpans,
-								spanGaps: selectedWidget?.spanGaps ?? true,
 								isLogScale: selectedWidget?.isLogScale || false,
 								bucketWidth: selectedWidget?.bucketWidth || 0,
 								bucketCount: selectedWidget?.bucketCount || 0,
@@ -578,7 +572,6 @@ function NewWidget({
 								softMin: selectedWidget?.softMin || 0,
 								softMax: selectedWidget?.softMax || 0,
 								fillSpans: selectedWidget?.fillSpans,
-								spanGaps: selectedWidget?.spanGaps ?? true,
 								isLogScale: selectedWidget?.isLogScale || false,
 								bucketWidth: selectedWidget?.bucketWidth || 0,
 								bucketCount: selectedWidget?.bucketCount || 0,
@@ -896,8 +889,6 @@ function NewWidget({
 							setLineStyle={setLineStyle}
 							showPoints={showPoints}
 							setShowPoints={setShowPoints}
-							spanGaps={spanGaps}
-							setSpanGaps={setSpanGaps}
 							opacity={opacity}
 							yAxisUnit={yAxisUnit}
 							columnUnits={columnUnits}

frontend/src/hooks/useAuthZ/constants.ts

@@ -1,2 +0,0 @@
-export const SINGLE_FLIGHT_WAIT_TIME_MS = 50;
-export const AUTHZ_CACHE_TIME = 20_000;

frontend/src/hooks/useAuthZ/legacy.ts

@@ -1,18 +0,0 @@
-import { buildPermission } from './utils';
-
-export const IsAdminPermission = buildPermission(
-	'assignee',
-	'role:signoz-admin',
-);
-export const IsEditorPermission = buildPermission(
-	'assignee',
-	'role:signoz-editor',
-);
-export const IsViewerPermission = buildPermission(
-	'assignee',
-	'role:signoz-viewer',
-);
-export const IsAnonymousPermission = buildPermission(
-	'assignee',
-	'role:signoz-anonymous',
-);

frontend/src/hooks/useAuthZ/types.ts

@@ -14,7 +14,7 @@ type ResourceTypeMap = {
 
 type RelationName = keyof RelationsByType;
 
-export type ResourcesForRelation<R extends RelationName> = Extract<
+type ResourcesForRelation<R extends RelationName> = Extract<
 	Resource,
 	{ type: RelationsByType[R][number] }
 >['name'];
@@ -50,26 +50,8 @@ export type AuthZCheckResponse = Record<
 	}
 >;
 
-export type UseAuthZOptions = {
-	/**
-	 * If false, the query/permissions will not be fetched.
-	 * Useful when you want to disable the query/permissions for a specific use case, like logout.
-	 *
-	 * @default true
-	 */
-	enabled?: boolean;
-};
-
 export type UseAuthZResult = {
-	/**
-	 * If query is cached, and refetch happens in background, this is false.
-	 */
 	isLoading: boolean;
-	/**
-	 * If query is fetching, even if happens in background, this is true.
-	 */
-	isFetching: boolean;
 	error: Error | null;
 	permissions: AuthZCheckResponse | null;
-	refetchPermissions: () => void;
 };

frontend/src/hooks/useAuthZ/useAuthZ.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useMemo } from 'react';
+import { useMemo } from 'react';
 import { useQueries } from 'react-query';
 import { authzCheck } from 'api/generated/services/authz';
 import type {
@@ -6,13 +6,7 @@ import type {
 	AuthtypesTransactionDTO,
 } from 'api/generated/services/sigNoz.schemas';
 
-import { AUTHZ_CACHE_TIME, SINGLE_FLIGHT_WAIT_TIME_MS } from './constants';
-import {
-	AuthZCheckResponse,
-	BrandedPermission,
-	UseAuthZOptions,
-	UseAuthZResult,
-} from './types';
+import { AuthZCheckResponse, BrandedPermission, UseAuthZResult } from './types';
 import {
 	gettableTransactionToPermission,
 	permissionToTransactionDto,
@@ -20,6 +14,8 @@ import {
 
 let ctx: Promise<AuthZCheckResponse> | null;
 let pendingPermissions: BrandedPermission[] = [];
+const SINGLE_FLIGHT_WAIT_TIME_MS = 50;
+const AUTHZ_CACHE_TIME = 20_000;
 
 function dispatchPermission(
 	permission: BrandedPermission,
@@ -74,12 +70,7 @@ async function fetchManyPermissions(
 	}, {} as AuthZCheckResponse);
 }
 
-export function useAuthZ(
-	permissions: BrandedPermission[],
-	options?: UseAuthZOptions,
-): UseAuthZResult {
-	const { enabled } = options ?? { enabled: true };
-
+export function useAuthZ(permissions: BrandedPermission[]): UseAuthZResult {
 	const queryResults = useQueries(
 		permissions.map((permission) => {
 			return {
@@ -89,7 +80,6 @@ export function useAuthZ(
 				refetchIntervalInBackground: false,
 				refetchOnWindowFocus: false,
 				refetchOnReconnect: true,
-				enabled,
 				queryFn: async (): Promise<AuthZCheckResponse> => {
 					const response = await dispatchPermission(permission);
 
@@ -106,10 +96,6 @@ export function useAuthZ(
 	const isLoading = useMemo(() => queryResults.some((q) => q.isLoading), [
 		queryResults,
 	]);
-	const isFetching = useMemo(() => queryResults.some((q) => q.isFetching), [
-		queryResults,
-	]);
-
 	const error = useMemo(
 		() =>
 			!isLoading
@@ -135,17 +121,9 @@ export function useAuthZ(
 		}, {} as AuthZCheckResponse);
 	}, [isLoading, error, queryResults]);
 
-	const refetchPermissions = useCallback(() => {
-		for (const query of queryResults) {
-			query.refetch();
-		}
-	}, [queryResults]);
-
 	return {
 		isLoading,
-		isFetching,
 		error,
 		permissions: data ?? null,
-		refetchPermissions,
 	};
 }

frontend/src/hooks/useAuthZ/utils.ts

@@ -3,9 +3,9 @@ import permissionsType from './permissions.type';
 import {
 	AuthZObject,
 	AuthZRelation,
+	AuthZResource,
 	BrandedPermission,
 	ResourceName,
-	ResourcesForRelation,
 	ResourceType,
 } from './types';
 
@@ -19,10 +19,11 @@ export function buildPermission<R extends AuthZRelation>(
 	return `${relation}${PermissionSeparator}${object}` as BrandedPermission;
 }
 
-export function buildObjectString<
-	R extends 'delete' | 'read' | 'update' | 'assignee'
->(resource: ResourcesForRelation<R>, objectId: string): AuthZObject<R> {
-	return `${resource}${ObjectSeparator}${objectId}` as AuthZObject<R>;
+export function buildObjectString(
+	resource: AuthZResource,
+	objectId: string,
+): `${AuthZResource}${typeof ObjectSeparator}${string}` {
+	return `${resource}${ObjectSeparator}${objectId}` as const;
 }
 
 export function parsePermission(

frontend/src/lib/uPlotV2/components/UPlotChart.tsx

@@ -6,9 +6,8 @@ import { LineChart } from 'lucide-react';
 import ErrorBoundaryFallback from 'pages/ErrorBoundaryFallback/ErrorBoundaryFallback';
 import uPlot, { AlignedData, Options } from 'uplot';
 
-import { usePlotContext } from '../../context/PlotContext';
-import { UPlotChartProps } from '../types';
-import { prepareAlignedData } from './utils';
+import { usePlotContext } from '../context/PlotContext';
+import { UPlotChartProps } from './types';
 
 /**
  * Check if dimensions have changed
@@ -84,11 +83,8 @@ export default function UPlotChart({
 			...configOptions,
 		} as Options;
 
-		// prepare final AlignedData
-		const preparedData = prepareAlignedData({ data, config });
-
 		// Create new plot instance
-		const plot = new uPlot(plotConfig, preparedData, containerRef.current);
+		const plot = new uPlot(plotConfig, data as AlignedData, containerRef.current);
 
 		if (plotRef) {
 			plotRef(plot);
@@ -166,8 +162,7 @@ export default function UPlotChart({
 		}
 		// Update data if only data changed
 		else if (!sameData(prevProps, currentProps) && plotInstanceRef.current) {
-			const preparedData = prepareAlignedData({ data, config });
-			plotInstanceRef.current.setData(preparedData as AlignedData);
+			plotInstanceRef.current.setData(data as AlignedData);
 		}
 
 		prevPropsRef.current = currentProps;

frontend/src/lib/uPlotV2/components/UPlotChart/utils.ts

@@ -1,16 +0,0 @@
-import { UPlotConfigBuilder } from 'lib/uPlotV2/config/UPlotConfigBuilder';
-import { applySpanGapsToAlignedData } from 'lib/uPlotV2/utils/dataUtils';
-import { AlignedData } from 'uplot';
-
-export function prepareAlignedData({
-	data,
-	config,
-}: {
-	data: AlignedData;
-	config: UPlotConfigBuilder;
-}): AlignedData {
-	const seriesSpanGaps = config.getSeriesSpanGapsOptions();
-	return seriesSpanGaps.length > 0
-		? applySpanGapsToAlignedData(data as AlignedData, seriesSpanGaps)
-		: (data as AlignedData);
-}

frontend/src/lib/uPlotV2/components/__tests__/UPlotChart.test.tsx

@@ -4,7 +4,7 @@ import { UPlotConfigBuilder } from 'lib/uPlotV2/config/UPlotConfigBuilder';
 import type { AlignedData } from 'uplot';
 
 import { PlotContextProvider } from '../../context/PlotContext';
-import UPlotChart from '../UPlotChart/UPlotChart';
+import UPlotChart from '../UPlotChart';
 
 // ---------------------------------------------------------------------------
 // Mocks
@@ -86,7 +86,6 @@ const createMockConfig = (): UPlotConfigBuilder => {
 		}),
 		getId: jest.fn().mockReturnValue(undefined),
 		getShouldSaveSelectionPreference: jest.fn().mockReturnValue(false),
-		getSeriesSpanGapsOptions: jest.fn().mockReturnValue([]),
 	} as unknown) as UPlotConfigBuilder;
 };
 
@@ -329,78 +328,6 @@ describe('UPlotChart', () => {
 		});
 	});
 
-	describe('spanGaps data transformation', () => {
-		it('inserts null break points before passing data to uPlot when a gap exceeds the numeric threshold', () => {
-			const config = createMockConfig();
-			// gap 0→100 = 100 > threshold 50 → null inserted at midpoint x=50
-			(config.getSeriesSpanGapsOptions as jest.Mock).mockReturnValue([
-				{ spanGaps: 50 },
-			]);
-			const data: AlignedData = [
-				[0, 100],
-				[1, 2],
-			];
-
-			render(<UPlotChart config={config} data={data} width={600} height={400} />, {
-				wrapper: Wrapper,
-			});
-
-			const [, receivedData] = mockUPlotConstructor.mock.calls[0];
-			expect(receivedData[0]).toEqual([0, 50, 100]);
-			expect(receivedData[1]).toEqual([1, null, 2]);
-		});
-
-		it('passes data through unchanged when no gap exceeds the numeric threshold', () => {
-			const config = createMockConfig();
-			// all gaps = 10, threshold = 50 → no insertions, same reference returned
-			(config.getSeriesSpanGapsOptions as jest.Mock).mockReturnValue([
-				{ spanGaps: 50 },
-			]);
-			const data: AlignedData = [
-				[0, 10, 20],
-				[1, 2, 3],
-			];
-
-			render(<UPlotChart config={config} data={data} width={600} height={400} />, {
-				wrapper: Wrapper,
-			});
-
-			const [, receivedData] = mockUPlotConstructor.mock.calls[0];
-			expect(receivedData).toBe(data);
-		});
-
-		it('transforms data passed to setData when data updates and a new gap exceeds the threshold', () => {
-			const config = createMockConfig();
-			(config.getSeriesSpanGapsOptions as jest.Mock).mockReturnValue([
-				{ spanGaps: 50 },
-			]);
-
-			// initial render: gap 10 < 50, no transformation
-			const initialData: AlignedData = [
-				[0, 10],
-				[1, 2],
-			];
-			// updated data: gap 100 > 50 → null inserted at midpoint x=50
-			const newData: AlignedData = [
-				[0, 100],
-				[3, 4],
-			];
-
-			const { rerender } = render(
-				<UPlotChart config={config} data={initialData} width={600} height={400} />,
-				{ wrapper: Wrapper },
-			);
-
-			rerender(
-				<UPlotChart config={config} data={newData} width={600} height={400} />,
-			);
-
-			const receivedData = instances[0].setData.mock.calls[0][0];
-			expect(receivedData[0]).toEqual([0, 50, 100]);
-			expect(receivedData[1]).toEqual([3, null, 4]);
-		});
-	});
-
 	describe('prop updates', () => {
 		it('calls setData without recreating the plot when only data changes', () => {
 			const config = createMockConfig();

frontend/src/lib/uPlotV2/config/UPlotConfigBuilder.ts

@@ -14,7 +14,6 @@ import {
 	STEP_INTERVAL_MULTIPLIER,
 } from '../constants';
 import { calculateWidthBasedOnStepInterval } from '../utils';
-import { SeriesSpanGapsOption } from '../utils/dataUtils';
 import {
 	ConfigBuilder,
 	ConfigBuilderProps,
@@ -162,13 +161,6 @@ export class UPlotConfigBuilder extends ConfigBuilder<
 		this.series.push(new UPlotSeriesBuilder(props));
 	}
 
-	getSeriesSpanGapsOptions(): SeriesSpanGapsOption[] {
-		return this.series.map((s) => {
-			const { spanGaps } = s.props;
-			return { spanGaps };
-		});
-	}
-
 	/**
 	 * Add a hook for extensibility
 	 */

frontend/src/lib/uPlotV2/config/UPlotSeriesBuilder.ts

@@ -4,7 +4,6 @@ import { calculateWidthBasedOnStepInterval } from 'lib/uPlotV2/utils';
 import uPlot, { Series } from 'uplot';
 
 import { generateGradientFill } from '../utils/generateGradientFill';
-import { isolatedPointFilter } from '../utils/seriesPointsFilter';
 import {
 	BarAlignment,
 	ConfigBuilder,
@@ -147,8 +146,20 @@ export class UPlotSeriesBuilder extends ConfigBuilder<SeriesProps, Series> {
 	}: {
 		resolvedLineColor: string;
 	}): Partial<Series.Points> {
-		const { lineWidth, pointSize, pointsFilter } = this.props;
+		const {
+			lineWidth,
+			pointSize,
+			pointsBuilder,
+			pointsFilter,
+			drawStyle,
+			showPoints,
+		} = this.props;
 
+		/**
+		 * If pointSize is not provided, use the lineWidth * POINT_SIZE_FACTOR
+		 * to determine the point size.
+		 * POINT_SIZE_FACTOR is 2, so the point size will be 2x the line width.
+		 */
 		const resolvedPointSize =
 			pointSize ?? (lineWidth ?? DEFAULT_LINE_WIDTH) * POINT_SIZE_FACTOR;
 
@@ -157,39 +168,19 @@ export class UPlotSeriesBuilder extends ConfigBuilder<SeriesProps, Series> {
 			fill: resolvedLineColor,
 			size: resolvedPointSize,
 			filter: pointsFilter || undefined,
-			show: this.resolvePointsShow(),
 		};
 
-		// When spanGaps is in threshold (numeric) mode, points hidden by default
-		// become invisible when isolated by injected gap-nulls (no line connects
-		// to them). Use a gap-based filter to show only those isolated points as
-		// dots. Do NOT set show=true here — the filter is called with show=false
-		// and returns specific indices to render; setting show=true would cause
-		// uPlot to call filter with show=true which short-circuits the logic and
-		// renders all points.
-		if (this.shouldApplyIsolatedPointFilter(pointsConfig.show)) {
-			pointsConfig.filter = isolatedPointFilter;
+		if (pointsBuilder) {
+			pointsConfig.show = pointsBuilder;
+		} else if (drawStyle === DrawStyle.Points) {
+			pointsConfig.show = true;
+		} else {
+			pointsConfig.show = !!showPoints;
 		}
 
 		return pointsConfig;
 	}
 
-	private resolvePointsShow(): Series.Points['show'] {
-		const { pointsBuilder, drawStyle, showPoints } = this.props;
-		if (pointsBuilder) {
-			return pointsBuilder;
-		}
-		if (drawStyle === DrawStyle.Points) {
-			return true;
-		}
-		return !!showPoints;
-	}
-
-	private shouldApplyIsolatedPointFilter(show: Series.Points['show']): boolean {
-		const { drawStyle, pointsFilter } = this.props;
-		return drawStyle === DrawStyle.Line && !pointsFilter && !show;
-	}
-
 	private getLineColor(): string {
 		const { colorMapping, label, lineColor, isDarkMode } = this.props;
 		if (!label) {
@@ -221,12 +212,7 @@ export class UPlotSeriesBuilder extends ConfigBuilder<SeriesProps, Series> {
 		return {
 			scale: scaleKey,
 			label,
-			// When spanGaps is numeric, we always disable uPlot's internal
-			// spanGaps behavior and rely on data-prep to implement the
-			// threshold-based null handling. When spanGaps is boolean we
-			// map it directly. When spanGaps is undefined we fall back to
-			// the default of true.
-			spanGaps: typeof spanGaps === 'number' ? false : spanGaps ?? true,
+			spanGaps: typeof spanGaps === 'boolean' ? spanGaps : false,
 			value: (): string => '',
 			pxAlign: true,
 			show,

frontend/src/lib/uPlotV2/config/__tests__/UPlotSeriesBuilder.test.ts

@@ -1,7 +1,6 @@
 import { themeColors } from 'constants/theme';
 import uPlot from 'uplot';
 
-import { isolatedPointFilter } from '../../utils/seriesPointsFilter';
 import type { SeriesProps } from '../types';
 import { DrawStyle, LineInterpolation, LineStyle } from '../types';
 import { POINT_SIZE_FACTOR, UPlotSeriesBuilder } from '../UPlotSeriesBuilder';
@@ -41,37 +40,6 @@ describe('UPlotSeriesBuilder', () => {
 		expect(typeof config.value).toBe('function');
 	});
 
-	it('maps boolean spanGaps directly to uPlot spanGaps', () => {
-		const trueBuilder = new UPlotSeriesBuilder(
-			createBaseProps({
-				spanGaps: true,
-			}),
-		);
-		const falseBuilder = new UPlotSeriesBuilder(
-			createBaseProps({
-				spanGaps: false,
-			}),
-		);
-
-		const trueConfig = trueBuilder.getConfig();
-		const falseConfig = falseBuilder.getConfig();
-
-		expect(trueConfig.spanGaps).toBe(true);
-		expect(falseConfig.spanGaps).toBe(false);
-	});
-
-	it('disables uPlot spanGaps when spanGaps is a number', () => {
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				spanGaps: 10000,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.spanGaps).toBe(false);
-	});
-
 	it('uses explicit lineColor when provided, regardless of mapping', () => {
 		const builder = new UPlotSeriesBuilder(
 			createBaseProps({
@@ -316,50 +284,4 @@ describe('UPlotSeriesBuilder', () => {
 
 		expect(config.points?.filter).toBe(pointsFilter);
 	});
-
-	it('assigns isolatedPointFilter and does not force show=true when spanGaps is numeric and no custom filter', () => {
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				drawStyle: DrawStyle.Line,
-				spanGaps: 10_000,
-				showPoints: false,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.points?.filter).toBe(isolatedPointFilter);
-		expect(config.points?.show).toBe(false);
-	});
-
-	it('does not assign isolatedPointFilter when a custom pointsFilter is provided alongside numeric spanGaps', () => {
-		const customFilter: uPlot.Series.Points.Filter = jest.fn(() => null);
-
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				drawStyle: DrawStyle.Line,
-				spanGaps: 10_000,
-				pointsFilter: customFilter,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.points?.filter).toBe(customFilter);
-	});
-
-	it('does not assign isolatedPointFilter when showPoints is true even with numeric spanGaps', () => {
-		const builder = new UPlotSeriesBuilder(
-			createBaseProps({
-				drawStyle: DrawStyle.Line,
-				spanGaps: 10_000,
-				showPoints: true,
-			}),
-		);
-
-		const config = builder.getConfig();
-
-		expect(config.points?.filter).toBeUndefined();
-		expect(config.points?.show).toBe(true);
-	});
 });

frontend/src/lib/uPlotV2/config/types.ts

@@ -99,11 +99,6 @@ export interface ScaleProps {
 	distribution?: DistributionType;
 }
 
-export enum DisconnectedValuesMode {
-	Never = 'never',
-	Threshold = 'threshold',
-}
-
 /**
  * Props for configuring a series
  */
@@ -180,16 +175,7 @@ export interface SeriesProps extends LineConfig, PointsConfig, BarConfig {
 	pointsFilter?: Series.Points.Filter;
 	pointsBuilder?: Series.Points.Show;
 	show?: boolean;
-	/**
-	 * Controls how nulls are treated for this series.
-	 *
-	 * - boolean: mapped directly to uPlot's spanGaps behavior
-	 * - number: interpreted as an X-axis threshold (same unit as ref values),
-	 *           where gaps smaller than this threshold are spanned by
-	 *           converting short null runs to undefined during data prep
-	 *           while uPlot's internal spanGaps is kept disabled.
-	 */
-	spanGaps?: boolean | number;
+	spanGaps?: boolean;
 	fillColor?: string;
 	fillMode?: FillMode;
 	isDarkMode?: boolean;

frontend/src/lib/uPlotV2/utils/__tests__/dataUtils.test.ts

@@ -1,12 +1,4 @@
-import uPlot from 'uplot';
-
-import {
-	applySpanGapsToAlignedData,
-	insertLargeGapNullsIntoAlignedData,
-	isInvalidPlotValue,
-	normalizePlotValue,
-	SeriesSpanGapsOption,
-} from '../dataUtils';
+import { isInvalidPlotValue, normalizePlotValue } from '../dataUtils';
 
 describe('dataUtils', () => {
 	describe('isInvalidPlotValue', () => {
@@ -67,217 +59,4 @@ describe('dataUtils', () => {
 			expect(normalizePlotValue(42.5)).toBe(42.5);
 		});
 	});
-
-	describe('insertLargeGapNullsIntoAlignedData', () => {
-		it('returns original data unchanged when no gap exceeds the threshold', () => {
-			// all gaps = 10, threshold = 25 → no insertions
-			const data: uPlot.AlignedData = [
-				[0, 10, 20, 30],
-				[1, 2, 3, 4],
-			];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: 25 }];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, options);
-
-			expect(result).toBe(data);
-		});
-
-		it('does not insert when the gap equals the threshold exactly', () => {
-			// gap = 50, threshold = 50 → condition is gap > threshold, not >=
-			const data: uPlot.AlignedData = [
-				[0, 50],
-				[1, 2],
-			];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: 50 }];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, options);
-
-			expect(result).toBe(data);
-		});
-
-		it('inserts a null at the midpoint when a single gap exceeds the threshold', () => {
-			// gap 0→100 = 100 > 50 → insert null at x=50
-			const data: uPlot.AlignedData = [
-				[0, 100],
-				[1, 2],
-			];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: 50 }];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, options);
-
-			expect(result[0]).toEqual([0, 50, 100]);
-			expect(result[1]).toEqual([1, null, 2]);
-		});
-
-		it('inserts nulls at every gap that exceeds the threshold', () => {
-			// gaps: 0→100=100, 100→110=10, 110→210=100; threshold=50
-			// → insert at 0→100 and 110→210
-			const data: uPlot.AlignedData = [
-				[0, 100, 110, 210],
-				[1, 2, 3, 4],
-			];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: 50 }];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, options);
-
-			expect(result[0]).toEqual([0, 50, 100, 110, 160, 210]);
-			expect(result[1]).toEqual([1, null, 2, 3, null, 4]);
-		});
-
-		it('inserts null for all series at a gap triggered by any one series', () => {
-			// series 0: threshold=50, gap=100 → triggers insertion
-			// series 1: threshold=200, gap=100 → would not trigger alone
-			// result: both series get null at the inserted x because the x-axis is shared
-			const data: uPlot.AlignedData = [
-				[0, 100],
-				[1, 2],
-				[3, 4],
-			];
-			const options: SeriesSpanGapsOption[] = [
-				{ spanGaps: 50 },
-				{ spanGaps: 200 },
-			];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, options);
-
-			expect(result[0]).toEqual([0, 50, 100]);
-			expect(result[1]).toEqual([1, null, 2]);
-			expect(result[2]).toEqual([3, null, 4]);
-		});
-
-		it('ignores boolean spanGaps options (only numeric values trigger insertion)', () => {
-			const data: uPlot.AlignedData = [
-				[0, 100],
-				[1, 2],
-			];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: true }];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, options);
-
-			expect(result).toBe(data);
-		});
-
-		it('returns original data when series options array is empty', () => {
-			const data: uPlot.AlignedData = [
-				[0, 100],
-				[1, 2],
-			];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, []);
-
-			expect(result).toBe(data);
-		});
-
-		it('returns original data when there is only one x point', () => {
-			const data: uPlot.AlignedData = [[0], [1]];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: 10 }];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, options);
-
-			expect(result).toBe(data);
-		});
-
-		it('preserves existing null values in the series alongside inserted ones', () => {
-			// original series already has a null; gap 0→100 also triggers insertion
-			const data: uPlot.AlignedData = [
-				[0, 100, 110],
-				[1, null, 2],
-			];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: 50 }];
-
-			const result = insertLargeGapNullsIntoAlignedData(data, options);
-
-			expect(result[0]).toEqual([0, 50, 100, 110]);
-			expect(result[1]).toEqual([1, null, null, 2]);
-		});
-	});
-
-	describe('applySpanGapsToAlignedData', () => {
-		const xs: uPlot.AlignedData[0] = [0, 10, 20, 30];
-
-		it('returns original data when there are no series', () => {
-			const data: uPlot.AlignedData = [xs];
-			const result = applySpanGapsToAlignedData(data, []);
-
-			expect(result).toBe(data);
-		});
-
-		it('leaves data unchanged when spanGaps is undefined', () => {
-			const ys = [1, null, 2, null];
-			const data: uPlot.AlignedData = [xs, ys];
-			const options: SeriesSpanGapsOption[] = [{}];
-
-			const result = applySpanGapsToAlignedData(data, options);
-
-			expect(result[1]).toEqual(ys);
-		});
-
-		it('converts nulls to undefined when spanGaps is true', () => {
-			const ys = [1, null, 2, null];
-			const data: uPlot.AlignedData = [xs, ys];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: true }];
-
-			const result = applySpanGapsToAlignedData(data, options);
-
-			expect(result[1]).toEqual([1, undefined, 2, undefined]);
-		});
-
-		it('leaves data unchanged when spanGaps is false', () => {
-			const ys = [1, null, 2, null];
-			const data: uPlot.AlignedData = [xs, ys];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: false }];
-
-			const result = applySpanGapsToAlignedData(data, options);
-
-			expect(result[1]).toEqual(ys);
-		});
-
-		it('inserts a null break point when a gap exceeds the numeric threshold', () => {
-			// gap 0→100 = 100 > 50 → null inserted at midpoint x=50
-			const data: uPlot.AlignedData = [
-				[0, 100, 110],
-				[1, 2, 3],
-			];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: 50 }];
-
-			const result = applySpanGapsToAlignedData(data, options);
-
-			expect(result[0]).toEqual([0, 50, 100, 110]);
-			expect(result[1]).toEqual([1, null, 2, 3]);
-		});
-
-		it('returns original data when no gap exceeds the numeric threshold', () => {
-			// all gaps = 10, threshold = 25 → no insertions
-			const data: uPlot.AlignedData = [xs, [1, 2, 3, 4]];
-			const options: SeriesSpanGapsOption[] = [{ spanGaps: 25 }];
-
-			const result = applySpanGapsToAlignedData(data, options);
-
-			expect(result).toBe(data);
-		});
-
-		it('applies both numeric gap insertion and boolean null-to-undefined in one pass', () => {
-			// series 0: spanGaps: 50 → gap 0→100 triggers a null break at midpoint x=50
-			// series 1: spanGaps: true → the inserted null at x=50 becomes undefined,
-			//   so the line spans over it rather than breaking
-			const data: uPlot.AlignedData = [
-				[0, 100],
-				[1, 2],
-				[3, 4],
-			];
-			const options: SeriesSpanGapsOption[] = [
-				{ spanGaps: 50 },
-				{ spanGaps: true },
-			];
-
-			const result = applySpanGapsToAlignedData(data, options);
-
-			// x-axis extended with the inserted midpoint
-			expect(result[0]).toEqual([0, 50, 100]);
-			// series 0: null at midpoint breaks the line
-			expect(result[1]).toEqual([1, null, 2]);
-			// series 1: null at midpoint converted to undefined → line spans over it
-			expect(result[2]).toEqual([3, undefined, 4]);
-		});
-	});
 });

frontend/src/lib/uPlotV2/utils/__tests__/seriesPointsFilter.test.ts

@@ -1,251 +0,0 @@
-import type uPlot from 'uplot';
-
-import {
-	findNearestNonNull,
-	findSandwichedIndices,
-	isolatedPointFilter,
-} from '../seriesPointsFilter';
-
-// ---------------------------------------------------------------------------
-// Minimal uPlot stub — only the surface used by seriesPointsFilter
-// ---------------------------------------------------------------------------
-
-function makeUPlot({
-	xData,
-	yData,
-	idxs,
-	valToPosFn,
-	posToIdxFn,
-}: {
-	xData: number[];
-	yData: (number | null | undefined)[];
-	idxs?: [number, number];
-	valToPosFn?: (val: number) => number;
-	posToIdxFn?: (pos: number) => number;
-}): uPlot {
-	return ({
-		data: [xData, yData],
-		series: [{}, { idxs: idxs ?? [0, yData.length - 1] }],
-		valToPos: jest.fn((val: number) => (valToPosFn ? valToPosFn(val) : val)),
-		posToIdx: jest.fn((pos: number) =>
-			posToIdxFn ? posToIdxFn(pos) : Math.round(pos),
-		),
-	} as unknown) as uPlot;
-}
-
-// ---------------------------------------------------------------------------
-// findNearestNonNull
-// ---------------------------------------------------------------------------
-
-describe('findNearestNonNull', () => {
-	it('returns the right neighbor when left side is null', () => {
-		const yData = [null, null, 42, null];
-		expect(findNearestNonNull(yData, 1)).toBe(2);
-	});
-
-	it('returns the left neighbor when right side is null', () => {
-		const yData = [null, 42, null, null];
-		expect(findNearestNonNull(yData, 2)).toBe(1);
-	});
-
-	it('prefers the right neighbor over the left when both exist at the same distance', () => {
-		const yData = [10, null, 20];
-		// j=1: right (idx 3) is out of bounds (undefined == null), left (idx 1) is null
-		// Actually right (idx 2) exists at j=1
-		expect(findNearestNonNull(yData, 1)).toBe(2);
-	});
-
-	it('returns approxIdx unchanged when no non-null value is found within 100 steps', () => {
-		const yData: (number | null)[] = Array(5).fill(null);
-		expect(findNearestNonNull(yData, 2)).toBe(2);
-	});
-
-	it('handles undefined values the same as null', () => {
-		const yData: (number | null | undefined)[] = [undefined, undefined, 99];
-		expect(findNearestNonNull(yData, 0)).toBe(2);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// findSandwichedIndices
-// ---------------------------------------------------------------------------
-
-describe('findSandwichedIndices', () => {
-	it('returns empty array when no consecutive gaps share a pixel boundary', () => {
-		const gaps = [
-			[0, 10],
-			[20, 30],
-		];
-		const yData = [1, null, null, 2];
-		const u = makeUPlot({ xData: [0, 1, 2, 3], yData });
-		expect(findSandwichedIndices(gaps, yData, u)).toEqual([]);
-	});
-
-	it('returns the index between two gaps that share a pixel boundary', () => {
-		// gaps[0] ends at 10, gaps[1] starts at 10 → sandwiched point at pixel 10
-		const gaps = [
-			[0, 10],
-			[10, 20],
-		];
-		// posToIdx(10) → 2
-		const yData = [null, null, 5, null, null];
-		const u = makeUPlot({ xData: [0, 1, 2, 3, 4], yData, posToIdxFn: () => 2 });
-		expect(findSandwichedIndices(gaps, yData, u)).toEqual([2]);
-	});
-
-	it('scans to nearest non-null when posToIdx lands on a null', () => {
-		// posToIdx returns 2 which is null; nearest non-null is index 3
-		const gaps = [
-			[0, 10],
-			[10, 20],
-		];
-		const yData = [null, null, null, 7, null];
-		const u = makeUPlot({ xData: [0, 1, 2, 3, 4], yData, posToIdxFn: () => 2 });
-		expect(findSandwichedIndices(gaps, yData, u)).toEqual([3]);
-	});
-
-	it('returns multiple indices when several gap pairs share boundaries', () => {
-		// Three consecutive gaps: [0,10], [10,20], [20,30]
-		// → two sandwiched points: between gaps 0-1 at px 10, between gaps 1-2 at px 20
-		const gaps = [
-			[0, 10],
-			[10, 20],
-			[20, 30],
-		];
-		const yData = [null, 1, null, 2, null];
-		const u = makeUPlot({
-			xData: [0, 1, 2, 3, 4],
-			yData,
-			posToIdxFn: (pos) => (pos === 10 ? 1 : 3),
-		});
-		expect(findSandwichedIndices(gaps, yData, u)).toEqual([1, 3]);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// isolatedPointFilter
-// ---------------------------------------------------------------------------
-
-describe('isolatedPointFilter', () => {
-	it('returns null when show is true (normal point rendering active)', () => {
-		const u = makeUPlot({ xData: [0, 1], yData: [1, null] });
-		expect(isolatedPointFilter(u, 1, true, [[0, 10]])).toBeNull();
-	});
-
-	it('returns null when gaps is null', () => {
-		const u = makeUPlot({ xData: [0, 1], yData: [1, null] });
-		expect(isolatedPointFilter(u, 1, false, null)).toBeNull();
-	});
-
-	it('returns null when gaps is empty', () => {
-		const u = makeUPlot({ xData: [0, 1], yData: [1, null] });
-		expect(isolatedPointFilter(u, 1, false, [])).toBeNull();
-	});
-
-	it('returns null when series idxs is undefined', () => {
-		const u = ({
-			data: [
-				[0, 1],
-				[1, null],
-			],
-			series: [{}, { idxs: undefined }],
-			valToPos: jest.fn(() => 0),
-			posToIdx: jest.fn(() => 0),
-		} as unknown) as uPlot;
-		expect(isolatedPointFilter(u, 1, false, [[0, 10]])).toBeNull();
-	});
-
-	it('includes firstIdx when the first gap starts at the first data point pixel', () => {
-		// xData[firstIdx=0] → valToPos → 5; gaps[0][0] === 5 → isolated leading point
-		const xData = [0, 1, 2, 3, 4];
-		const yData = [10, null, null, null, 20];
-		const u = makeUPlot({
-			xData,
-			yData,
-			idxs: [0, 4],
-			valToPosFn: (val) => (val === 0 ? 5 : 40), // firstPos=5, lastPos=40
-		});
-		// gaps[0][0] === 5 (firstPos), gaps last end !== 40
-		const result = isolatedPointFilter(u, 1, false, [
-			[5, 15],
-			[20, 30],
-		]);
-		expect(result).toContain(0); // firstIdx
-	});
-
-	it('includes lastIdx when the last gap ends at the last data point pixel', () => {
-		const xData = [0, 1, 2, 3, 4];
-		const yData = [10, null, null, null, 20];
-		const u = makeUPlot({
-			xData,
-			yData,
-			idxs: [0, 4],
-			valToPosFn: (val) => (val === 0 ? 5 : 40), // firstPos=5, lastPos=40
-		});
-		// gaps last end === 40 (lastPos), gaps[0][0] !== 5
-		const result = isolatedPointFilter(u, 1, false, [
-			[10, 20],
-			[30, 40],
-		]);
-		expect(result).toContain(4); // lastIdx
-	});
-
-	it('includes sandwiched index between two gaps sharing a pixel boundary', () => {
-		const xData = [0, 1, 2, 3, 4];
-		const yData = [null, null, 5, null, null];
-		const u = makeUPlot({
-			xData,
-			yData,
-			idxs: [0, 4],
-			valToPosFn: () => 99, // firstPos/lastPos won't match gap boundaries
-			posToIdxFn: () => 2,
-		});
-		const result = isolatedPointFilter(u, 1, false, [
-			[0, 50],
-			[50, 100],
-		]);
-		expect(result).toContain(2);
-	});
-
-	it('returns null when no isolated points are found', () => {
-		const xData = [0, 1, 2];
-		const yData = [1, 2, 3];
-		const u = makeUPlot({
-			xData,
-			yData,
-			idxs: [0, 2],
-			// firstPos = 10, lastPos = 30 — neither matches any gap boundary
-			valToPosFn: (val) => (val === 0 ? 10 : 30),
-		});
-		// gaps don't share boundaries and don't touch firstPos/lastPos
-		const result = isolatedPointFilter(u, 1, false, [
-			[0, 5],
-			[15, 20],
-		]);
-		expect(result).toBeNull();
-	});
-
-	it('returns all three kinds of isolated points in one pass', () => {
-		// Leading (firstPos=0 === gaps[0][0]), sandwiched (gaps[1] and gaps[2] share 50),
-		// trailing (lastPos=100 === gaps last end)
-		const xData = [0, 1, 2, 3, 4];
-		const yData = [1, null, 2, null, 3];
-		const u = makeUPlot({
-			xData,
-			yData,
-			idxs: [0, 4],
-			valToPosFn: (val) => (val === 0 ? 0 : 100),
-			posToIdxFn: () => 2, // sandwiched point at idx 2
-		});
-		const gaps = [
-			[0, 20],
-			[40, 50],
-			[50, 80],
-			[90, 100],
-		];
-		const result = isolatedPointFilter(u, 1, false, gaps);
-		expect(result).toContain(0); // leading
-		expect(result).toContain(2); // sandwiched
-		expect(result).toContain(4); // trailing
-	});
-});

frontend/src/lib/uPlotV2/utils/dataUtils.ts

@@ -24,10 +24,10 @@ export function isInvalidPlotValue(value: unknown): boolean {
 		}
 
 		// Try to parse the string as a number
-		const parsedNumber = parseFloat(value);
+		const numValue = parseFloat(value);
 
 		// If parsing failed or resulted in a non-finite number, it's invalid
-		if (Number.isNaN(parsedNumber) || !Number.isFinite(parsedNumber)) {
+		if (Number.isNaN(numValue) || !Number.isFinite(numValue)) {
 			return true;
 		}
 	}
@@ -51,178 +51,3 @@ export function normalizePlotValue(
 	// Already a valid number
 	return value as number;
 }
-
-export interface SeriesSpanGapsOption {
-	spanGaps?: boolean | number;
-}
-
-// Internal type alias: a series value array that may contain nulls/undefineds.
-// uPlot uses null to draw a visible gap and undefined to represent "no sample"
-// (the line continues across undefined points but breaks at null ones).
-type SeriesArray = Array<number | null | undefined>;
-
-/**
- * Returns true if the given gap size exceeds the numeric spanGaps threshold
- * of at least one series. Used to decide whether to insert a null break point.
- */
-function gapExceedsThreshold(
-	gapSize: number,
-	seriesOptions: SeriesSpanGapsOption[],
-): boolean {
-	return seriesOptions.some(
-		({ spanGaps }) =>
-			typeof spanGaps === 'number' && spanGaps > 0 && gapSize > spanGaps,
-	);
-}
-
-/**
- * For each series with a numeric spanGaps threshold, insert a null data point
- * between consecutive x timestamps whose gap exceeds the threshold.
- *
- * Why: uPlot draws a continuous line between all non-null points. When the
- * time gap between two consecutive samples is larger than the configured
- * spanGaps value, we inject a synthetic null at the midpoint so uPlot renders
- * a visible break instead of a misleading straight line across the gap.
- *
- * Because uPlot's AlignedData shares a single x-axis across all series, a null
- * is inserted for every series at each position where any series needs a break.
- *
- * Two-pass approach for performance:
- *   Pass 1 — count how many nulls will be inserted (no allocations).
- *   Pass 2 — fill pre-allocated output arrays by index (no push/reallocation).
- */
-export function insertLargeGapNullsIntoAlignedData(
-	data: uPlot.AlignedData,
-	seriesOptions: SeriesSpanGapsOption[],
-): uPlot.AlignedData {
-	const [xValues, ...seriesValues] = data;
-
-	if (
-		!Array.isArray(xValues) ||
-		xValues.length < 2 ||
-		seriesValues.length === 0
-	) {
-		return data;
-	}
-
-	const timestamps = xValues as number[];
-	const totalPoints = timestamps.length;
-
-	// Pass 1: count insertions needed so we know the exact output length.
-	// This lets us pre-allocate arrays rather than growing them dynamically.
-	let insertionCount = 0;
-	for (let i = 0; i < totalPoints - 1; i += 1) {
-		if (gapExceedsThreshold(timestamps[i + 1] - timestamps[i], seriesOptions)) {
-			insertionCount += 1;
-		}
-	}
-
-	// No gaps exceed any threshold — return the original data unchanged.
-	if (insertionCount === 0) {
-		return data;
-	}
-
-	// Pass 2: build output arrays of exact size and fill them.
-	// `writeIndex` is the write cursor into the output arrays.
-	const outputLen = totalPoints + insertionCount;
-	const newX = new Array<number>(outputLen);
-	const newSeries: SeriesArray[] = seriesValues.map(
-		() => new Array<number | null | undefined>(outputLen),
-	);
-
-	let writeIndex = 0;
-	for (let i = 0; i < totalPoints; i += 1) {
-		// Copy the real data point at position i
-		newX[writeIndex] = timestamps[i];
-		for (
-			let seriesIndex = 0;
-			seriesIndex < seriesValues.length;
-			seriesIndex += 1
-		) {
-			newSeries[seriesIndex][writeIndex] = (seriesValues[
-				seriesIndex
-			] as SeriesArray)[i];
-		}
-		writeIndex += 1;
-
-		// If the gap to the next x timestamp exceeds the threshold, insert a
-		// synthetic null at the midpoint. The midpoint x is placed halfway
-		// between timestamps[i] and timestamps[i+1] (minimum 1 unit past timestamps[i] to stay unique).
-		if (
-			i < totalPoints - 1 &&
-			gapExceedsThreshold(timestamps[i + 1] - timestamps[i], seriesOptions)
-		) {
-			newX[writeIndex] =
-				timestamps[i] +
-				Math.max(1, Math.floor((timestamps[i + 1] - timestamps[i]) / 2));
-			for (
-				let seriesIndex = 0;
-				seriesIndex < seriesValues.length;
-				seriesIndex += 1
-			) {
-				newSeries[seriesIndex][writeIndex] = null; // null tells uPlot to break the line here
-			}
-			writeIndex += 1;
-		}
-	}
-
-	return [newX, ...newSeries] as uPlot.AlignedData;
-}
-
-/**
- * Apply per-series spanGaps (boolean | number) handling to an aligned dataset.
- *
- * spanGaps controls how uPlot handles gaps in a series:
- *   - boolean true  → convert null → undefined so uPlot spans over every gap
- *                     (draws a continuous line, skipping missing samples)
- *   - boolean false → no change; nulls render as visible breaks (default)
- *   - number        → insert a null break point between any two consecutive
- *                     timestamps whose difference exceeds the threshold;
- *                     gaps smaller than the threshold are left as-is
- *
- * The input data is expected to be of the form:
- * [xValues, series1Values, series2Values, ...]
- */
-export function applySpanGapsToAlignedData(
-	data: uPlot.AlignedData,
-	seriesOptions: SeriesSpanGapsOption[],
-): uPlot.AlignedData {
-	const [xValues, ...seriesValues] = data;
-
-	if (!Array.isArray(xValues) || seriesValues.length === 0) {
-		return data;
-	}
-
-	// Numeric spanGaps: operates on the whole dataset at once because inserting
-	// null break points requires modifying the shared x-axis.
-	const hasNumericSpanGaps = seriesOptions.some(
-		({ spanGaps }) => typeof spanGaps === 'number',
-	);
-	const gapProcessed = hasNumericSpanGaps
-		? insertLargeGapNullsIntoAlignedData(data, seriesOptions)
-		: data;
-
-	// Boolean spanGaps === true: convert null → undefined per series so uPlot
-	// draws a continuous line across missing samples instead of breaking it.
-	// Skip this pass entirely if no series uses spanGaps: true.
-	const hasBooleanTrue = seriesOptions.some(({ spanGaps }) => spanGaps === true);
-	if (!hasBooleanTrue) {
-		return gapProcessed;
-	}
-
-	const [newX, ...newSeries] = gapProcessed;
-	const transformedSeries = newSeries.map((yValues, seriesIndex) => {
-		const { spanGaps } = seriesOptions[seriesIndex] ?? {};
-		if (spanGaps !== true) {
-			// This series doesn't use spanGaps: true — leave it unchanged.
-			return yValues;
-		}
-		// Replace null with undefined: uPlot skips undefined points without
-		// breaking the line, effectively spanning over the gap.
-		return (yValues as SeriesArray).map((pointValue) =>
-			pointValue === null ? undefined : pointValue,
-		) as uPlot.AlignedData[0];
-	});
-
-	return [newX, ...transformedSeries] as uPlot.AlignedData;
-}

frontend/src/lib/uPlotV2/utils/seriesPointsFilter.ts

@@ -1,93 +0,0 @@
-import uPlot from 'uplot';
-
-/**
- * Scans outward from approxIdx to find the nearest non-null data index.
- * posToIdx can land on a null when pixel density exceeds 1 point-per-pixel.
- */
-export function findNearestNonNull(
-	yData: (number | null | undefined)[],
-	approxIdx: number,
-): number {
-	for (let j = 1; j < 100; j++) {
-		if (yData[approxIdx + j] != null) {
-			return approxIdx + j;
-		}
-		if (yData[approxIdx - j] != null) {
-			return approxIdx - j;
-		}
-	}
-	return approxIdx;
-}
-
-/**
- * Returns data indices of points sandwiched between two consecutive gaps that
- * share a pixel boundary — meaning a point (or cluster) is isolated between them.
- */
-export function findSandwichedIndices(
-	gaps: number[][],
-	yData: (number | null | undefined)[],
-	uPlotInstance: uPlot,
-): number[] {
-	const indices: number[] = [];
-	for (let i = 0; i < gaps.length; i++) {
-		const nextGap = gaps[i + 1];
-		if (nextGap && gaps[i][1] === nextGap[0]) {
-			const approxIdx = uPlotInstance.posToIdx(gaps[i][1], true);
-			indices.push(
-				yData[approxIdx] == null ? findNearestNonNull(yData, approxIdx) : approxIdx,
-			);
-		}
-	}
-	return indices;
-}
-
-/**
- * Points filter that shows data points isolated by gap-nulls (no connecting line).
- * Used when spanGaps threshold mode injects nulls around gaps — without this,
- * lone points become invisible because no line connects to them.
- *
- * Uses uPlot's gap pixel array rather than checking raw null neighbors in the
- * data array. Returns an array of data indices (not a bitmask); null = no points.
- *
-
- */
-// eslint-disable-next-line max-params
-export function isolatedPointFilter(
-	uPlotInstance: uPlot,
-	seriesIdx: number,
-	show: boolean,
-	gaps?: null | number[][],
-): number[] | null {
-	if (show || !gaps || gaps.length === 0) {
-		return null;
-	}
-
-	const idxs = uPlotInstance.series[seriesIdx].idxs;
-	if (!idxs) {
-		return null;
-	}
-
-	const [firstIdx, lastIdx] = idxs;
-	const xData = uPlotInstance.data[0] as number[];
-	const yData = uPlotInstance.data[seriesIdx] as (number | null | undefined)[];
-
-	// valToPos with canvas=true matches the pixel space used by the gaps array.
-	const firstPos = Math.round(
-		uPlotInstance.valToPos(xData[firstIdx], 'x', true),
-	);
-	const lastPos = Math.round(uPlotInstance.valToPos(xData[lastIdx], 'x', true));
-
-	const filtered: number[] = [];
-
-	if (gaps[0][0] === firstPos) {
-		filtered.push(firstIdx);
-	}
-
-	filtered.push(...findSandwichedIndices(gaps, yData, uPlotInstance));
-
-	if (gaps[gaps.length - 1][1] === lastPos) {
-		filtered.push(lastIdx);
-	}
-
-	return filtered.length ? filtered : null;
-}

frontend/src/mocks-server/__mockdata__/invite_user.ts

@@ -1,25 +0,0 @@
-export const inviteUser = {
-	status: 'success',
-	data: {
-		statusCode: 200,
-		error: null,
-		payload: [
-			{
-				email: 'jane@doe.com',
-				name: 'Jane',
-				token: 'testtoken',
-				createdAt: 1715741587,
-				role: 'VIEWER',
-				organization: 'test',
-			},
-			{
-				email: 'test+in@singoz.io',
-				name: '',
-				token: 'testtoken1',
-				createdAt: 1720095913,
-				role: 'VIEWER',
-				organization: 'test',
-			},
-		],
-	},
-};

frontend/src/mocks-server/handlers.ts

@@ -9,7 +9,6 @@ import {
 	getDashboardById,
 } from './__mockdata__/dashboards';
 import { explorerView } from './__mockdata__/explorer_views';
-import { inviteUser } from './__mockdata__/invite_user';
 import { licensesSuccessResponse } from './__mockdata__/licenses';
 import { membersResponse } from './__mockdata__/members';
 import { queryRangeSuccessResponse } from './__mockdata__/query_range';
@@ -175,11 +174,14 @@ export const handlers = [
 		res(ctx.status(200), ctx.json(getDashboardById)),
 	),
 
-	rest.get('http://localhost/api/v1/invite', (_, res, ctx) =>
-		res(ctx.status(200), ctx.json(inviteUser)),
-	),
 	rest.post('http://localhost/api/v1/invite', (_, res, ctx) =>
-		res(ctx.status(200), ctx.json(inviteUser)),
+		res(
+			ctx.status(200),
+			ctx.json({
+				status: 'success',
+				data: 'invite sent successfully',
+			}),
+		),
 	),
 	rest.put('http://localhost/api/v1/user/:id', (_, res, ctx) =>
 		res(

frontend/src/pages/SignUp/SignUp.tsx

@@ -1,13 +1,9 @@
-import { useEffect, useMemo, useState } from 'react';
-import { useQuery } from 'react-query';
-import { useLocation } from 'react-router-dom';
+import { useMemo, useState } from 'react';
 import { Button } from '@signozhq/button';
 import { Callout } from '@signozhq/callout';
 import { Input } from '@signozhq/input';
 import { Form, Input as AntdInput, Typography } from 'antd';
 import logEvent from 'api/common/logEvent';
-import accept from 'api/v1/invite/id/accept';
-import getInviteDetails from 'api/v1/invite/id/get';
 import signUpApi from 'api/v1/register/post';
 import passwordAuthNContext from 'api/v2/sessions/email_password/post';
 import afterLogin from 'AppRoutes/utils';
@@ -15,9 +11,7 @@ import AuthError from 'components/AuthError/AuthError';
 import AuthPageContainer from 'components/AuthPageContainer';
 import { useNotifications } from 'hooks/useNotifications';
 import { ArrowRight, CircleAlert } from 'lucide-react';
-import { SuccessResponseV2 } from 'types/api';
 import APIError from 'types/api/error';
-import { InviteDetails } from 'types/api/user/getInviteDetails';
 
 import { FormContainer, Label } from './styles';
 
@@ -39,22 +33,6 @@ function SignUp(): JSX.Element {
 		false,
 	);
 	const [formError, setFormError] = useState<APIError | null>();
-	const { search } = useLocation();
-	const params = new URLSearchParams(search);
-	const token = params.get('token');
-	const [isDetailsDisable, setIsDetailsDisable] = useState<boolean>(false);
-
-	const getInviteDetailsResponse = useQuery<
-		SuccessResponseV2<InviteDetails>,
-		APIError
-	>({
-		queryFn: () =>
-			getInviteDetails({
-				inviteId: token || '',
-			}),
-		queryKey: ['getInviteDetails', token],
-		enabled: token !== null,
-	});
 
 	const { notifications } = useNotifications();
 	const [form] = Form.useForm<FormValues>();
@@ -64,49 +42,6 @@ function SignUp(): JSX.Element {
 	const password = Form.useWatch('password', form);
 	const confirmPassword = Form.useWatch('confirmPassword', form);
 
-	useEffect(() => {
-		if (
-			getInviteDetailsResponse.status === 'success' &&
-			getInviteDetailsResponse.data.data
-		) {
-			const responseDetails = getInviteDetailsResponse.data.data;
-			form.setFieldValue('email', responseDetails.email);
-			form.setFieldValue('organizationName', responseDetails.organization);
-			setIsDetailsDisable(true);
-
-			logEvent('Account Creation Page Visited', {
-				email: responseDetails.email,
-				name: responseDetails.name,
-				company_name: responseDetails.organization,
-				source: 'SigNoz Cloud',
-			});
-		}
-	}, [
-		getInviteDetailsResponse.data?.data,
-		form,
-		getInviteDetailsResponse.status,
-	]);
-
-	useEffect(() => {
-		if (
-			getInviteDetailsResponse.status === 'success' &&
-			getInviteDetailsResponse?.error
-		) {
-			const { error } = getInviteDetailsResponse;
-			notifications.error({
-				message: (error as APIError).getErrorCode(),
-				description: (error as APIError).getErrorMessage(),
-			});
-		}
-	}, [
-		getInviteDetailsResponse,
-		getInviteDetailsResponse.data,
-		getInviteDetailsResponse.status,
-		notifications,
-	]);
-
-	const isSignUp = token === null;
-
 	const signUp = async (values: FormValues): Promise<void> => {
 		try {
 			const { organizationName, password, email } = values;
@@ -114,7 +49,6 @@ function SignUp(): JSX.Element {
 				email,
 				orgDisplayName: organizationName,
 				password,
-				token: params.get('token') || undefined,
 			});
 
 			const token = await passwordAuthNContext({
@@ -129,25 +63,6 @@ function SignUp(): JSX.Element {
 		}
 	};
 
-	const acceptInvite = async (values: FormValues): Promise<void> => {
-		try {
-			const { password, email } = values;
-			const user = await accept({
-				password,
-				token: params.get('token') || '',
-			});
-			const token = await passwordAuthNContext({
-				email,
-				password,
-				orgId: user.data.orgId,
-			});
-
-			await afterLogin(token.data.accessToken, token.data.refreshToken);
-		} catch (error) {
-			setFormError(error as APIError);
-		}
-	};
-
 	const handleSubmit = (): void => {
 		(async (): Promise<void> => {
 			try {
@@ -155,14 +70,10 @@ function SignUp(): JSX.Element {
 				setLoading(true);
 				setFormError(null);
 
-				if (isSignUp) {
-					await signUp(values);
-					logEvent('Account Created Successfully', {
-						email: values.email,
-					});
-				} else {
-					await acceptInvite(values);
-				}
+				await signUp(values);
+				logEvent('Account Created Successfully', {
+					email: values.email,
+				});
 
 				setLoading(false);
 			} catch (error) {
@@ -247,7 +158,6 @@ function SignUp(): JSX.Element {
 										autoFocus
 										required
 										id="signupEmail"
-										disabled={isDetailsDisable}
 										className="signup-form-input"
 									/>
 								</FormContainer.Item>
@@ -291,15 +201,13 @@ function SignUp(): JSX.Element {
 						</div>
 					</div>
 
-					{isSignUp && (
-						<Callout
-							type="info"
-							size="small"
-							showIcon
-							className="signup-info-callout"
-							description="This will create an admin account. If you are not an admin, please ask your admin for an invite link"
-						/>
-					)}
+					<Callout
+						type="info"
+						size="small"
+						showIcon
+						className="signup-info-callout"
+						description="This will create an admin account. If you are not an admin, please ask your admin for an invite link"
+					/>
 
 					{confirmPasswordError && (
 						<Callout

frontend/src/pages/SignUp/__tests__/SignUp.test.tsx

@@ -1,7 +1,6 @@
 import afterLogin from 'AppRoutes/utils';
 import { rest, server } from 'mocks-server/server';
 import { render, screen, userEvent, waitFor } from 'tests/test-utils';
-import { InviteDetails } from 'types/api/user/getInviteDetails';
 import { SignupResponse } from 'types/api/v1/register/post';
 import { Token } from 'types/api/v2/sessions/email_password/post';
 
@@ -32,14 +31,8 @@ jest.mock('lib/history', () => ({
 
 const REGISTER_ENDPOINT = '*/api/v1/register';
 const EMAIL_PASSWORD_ENDPOINT = '*/api/v2/sessions/email_password';
-const INVITE_DETAILS_ENDPOINT = '*/api/v1/invite/*';
-const ACCEPT_INVITE_ENDPOINT = '*/api/v1/invite/accept';
 
-interface MockSignupResponse extends SignupResponse {
-	orgId: string;
-}
-
-const mockSignupResponse: MockSignupResponse = {
+const mockSignupResponse: SignupResponse = {
 	orgId: 'test-org-id',
 	createdAt: Date.now(),
 	email: 'test@signoz.io',
@@ -53,15 +46,6 @@ const mockTokenResponse: Token = {
 	refreshToken: 'mock-refresh-token',
 };
 
-const mockInviteDetails: InviteDetails = {
-	email: 'invited@signoz.io',
-	name: 'Invited User',
-	organization: 'Test Org',
-	createdAt: Date.now(),
-	role: 'ADMIN',
-	token: 'invite-token-123',
-};
-
 describe('SignUp Component - Regular Signup', () => {
 	beforeEach(() => {
 		jest.clearAllMocks();
@@ -288,242 +272,3 @@ describe('SignUp Component - Regular Signup', () => {
 		});
 	});
 });
-
-describe('SignUp Component - Accept Invite', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-		window.history.pushState({}, '', '/signup?token=invite-token-123');
-	});
-
-	afterEach(() => {
-		server.resetHandlers();
-	});
-
-	describe('Initial Render with Invite', () => {
-		it('pre-fills form fields from invite details', async () => {
-			server.use(
-				rest.get(INVITE_DETAILS_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(200),
-						ctx.json({
-							data: mockInviteDetails,
-							status: 'success',
-						}),
-					),
-				),
-			);
-
-			render(<SignUp />, undefined, {
-				initialRoute: '/signup?token=invite-token-123',
-			});
-
-			const emailInput = await screen.findByLabelText(/email address/i);
-
-			await waitFor(() => {
-				expect(emailInput).toHaveValue('invited@signoz.io');
-			});
-		});
-
-		it('disables email field when invite details are loaded', async () => {
-			server.use(
-				rest.get(INVITE_DETAILS_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(200),
-						ctx.json({
-							data: mockInviteDetails,
-							status: 'success',
-						}),
-					),
-				),
-			);
-
-			render(<SignUp />, undefined, {
-				initialRoute: '/signup?token=invite-token-123',
-			});
-
-			const emailInput = await screen.findByLabelText(/email address/i);
-
-			await waitFor(() => {
-				expect(emailInput).toBeDisabled();
-			});
-		});
-
-		it('does not show admin account info callout for invite flow', async () => {
-			server.use(
-				rest.get(INVITE_DETAILS_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(200),
-						ctx.json({
-							data: mockInviteDetails,
-							status: 'success',
-						}),
-					),
-				),
-			);
-
-			render(<SignUp />, undefined, {
-				initialRoute: '/signup?token=invite-token-123',
-			});
-
-			await waitFor(() => {
-				expect(
-					screen.queryByText(/this will create an admin account/i),
-				).not.toBeInTheDocument();
-			});
-		});
-	});
-
-	describe('Successful Invite Acceptance', () => {
-		it('successfully accepts invite and logs in user', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			server.use(
-				rest.get(INVITE_DETAILS_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(200),
-						ctx.json({
-							data: mockInviteDetails,
-							status: 'success',
-						}),
-					),
-				),
-				rest.post(ACCEPT_INVITE_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(200),
-						ctx.json({
-							data: mockSignupResponse,
-							status: 'success',
-						}),
-					),
-				),
-				rest.post(EMAIL_PASSWORD_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(200),
-						ctx.json({
-							data: mockTokenResponse,
-							status: 'success',
-						}),
-					),
-				),
-			);
-
-			render(<SignUp />, undefined, {
-				initialRoute: '/signup?token=invite-token-123',
-			});
-
-			const emailInput = await screen.findByLabelText(/email address/i);
-			await waitFor(() => {
-				expect(emailInput).toHaveValue('invited@signoz.io');
-			});
-
-			const passwordInput = screen.getByPlaceholderText(/enter new password/i);
-			const confirmPasswordInput = screen.getByPlaceholderText(
-				/confirm your new password/i,
-			);
-			const submitButton = screen.getByRole('button', {
-				name: /access my workspace/i,
-			});
-
-			await user.type(passwordInput, 'password123');
-			await user.type(confirmPasswordInput, 'password123');
-
-			await waitFor(() => {
-				expect(submitButton).not.toBeDisabled();
-			});
-
-			await user.click(submitButton);
-
-			await waitFor(() => {
-				expect(mockAfterLogin).toHaveBeenCalledWith(
-					'mock-access-token',
-					'mock-refresh-token',
-				);
-			});
-		});
-	});
-
-	describe('Error Handling for Invite', () => {
-		it('displays error when invite details fetch fails', async () => {
-			server.use(
-				rest.get(INVITE_DETAILS_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(404),
-						ctx.json({
-							error: {
-								code: 'INVITE_NOT_FOUND',
-								message: 'Invite not found',
-							},
-						}),
-					),
-				),
-			);
-
-			render(<SignUp />, undefined, {
-				initialRoute: '/signup?token=invalid-token',
-			});
-
-			// Verify form is still accessible and fields are enabled
-			const emailInput = await screen.findByLabelText(/email address/i);
-
-			expect(emailInput).toBeInTheDocument();
-			expect(emailInput).not.toBeDisabled();
-		});
-
-		it('displays error when accept invite API fails', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			server.use(
-				rest.get(INVITE_DETAILS_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(200),
-						ctx.json({
-							data: mockInviteDetails,
-							status: 'success',
-						}),
-					),
-				),
-				rest.post(ACCEPT_INVITE_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(400),
-						ctx.json({
-							error: {
-								code: 'INVALID_TOKEN',
-								message: 'Invalid or expired invite token',
-							},
-						}),
-					),
-				),
-			);
-
-			render(<SignUp />, undefined, {
-				initialRoute: '/signup?token=expired-token',
-			});
-
-			const emailInput = await screen.findByLabelText(/email address/i);
-			await waitFor(() => {
-				expect(emailInput).toHaveValue('invited@signoz.io');
-			});
-
-			const passwordInput = screen.getByPlaceholderText(/enter new password/i);
-			const confirmPasswordInput = screen.getByPlaceholderText(
-				/confirm your new password/i,
-			);
-			const submitButton = screen.getByRole('button', {
-				name: /access my workspace/i,
-			});
-
-			await user.type(passwordInput, 'password123');
-			await user.type(confirmPasswordInput, 'password123');
-
-			await waitFor(() => {
-				expect(submitButton).not.toBeDisabled();
-			});
-
-			await user.click(submitButton);
-
-			expect(
-				await screen.findByText(/invalid or expired invite token/i),
-			).toBeInTheDocument();
-		});
-	});
-});

frontend/src/pages/UnAuthorized/index.styles.scss

@@ -1,5 +0,0 @@
-.unauthorized-page {
-	&__description {
-		text-align: center;
-	}
-}

frontend/src/pages/UnAuthorized/index.tsx

@@ -1,51 +1,20 @@
-import { useCallback } from 'react';
 import { Space, Typography } from 'antd';
 import UnAuthorized from 'assets/UnAuthorized';
-import { Container } from 'components/NotFound/styles';
-import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
-import { useQueryState } from 'nuqs';
-import { handleContactSupport } from 'pages/Integrations/utils';
-
-import { useAppContext } from '../../providers/App/App';
-import { USER_ROLES } from '../../types/roles';
-
-import './index.styles.scss';
+import { Button, Container } from 'components/NotFound/styles';
+import ROUTES from 'constants/routes';
 
 function UnAuthorizePage(): JSX.Element {
-	const [debugCurrentRole] = useQueryState('currentRole');
-	const { user } = useAppContext();
-	const { isCloudUser: isCloudUserVal } = useGetTenantLicense();
-
-	const userIsAnonymous =
-		debugCurrentRole === USER_ROLES.ANONYMOUS ||
-		user.role === USER_ROLES.ANONYMOUS;
-	const mistakeMessage = userIsAnonymous
-		? 'If you believe this is a mistake, please contact your administrator or'
-		: 'Please contact your administrator.';
-
-	const handleContactSupportClick = useCallback((): void => {
-		handleContactSupport(isCloudUserVal);
-	}, [isCloudUserVal]);
-
 	return (
-		<Container className="unauthorized-page">
+		<Container>
 			<Space align="center" direction="vertical">
-				<UnAuthorized width={64} height={64} />
-				<Typography.Title level={3}>Access Restricted</Typography.Title>
+				<UnAuthorized />
+				<Typography.Title level={3}>
+					Oops.. you don&apos;t have permission to view this page
+				</Typography.Title>
 
-				<p className="unauthorized-page__description">
-					It looks like you don&lsquo;t have permission to view this page. <br />
-					{mistakeMessage}
-					{userIsAnonymous ? (
-						<Typography.Link
-							className="contact-support-link"
-							onClick={handleContactSupportClick}
-						>
-							{' '}
-							reach out to us.
-						</Typography.Link>
-					) : null}
-				</p>
+				<Button to={ROUTES.HOME} tabIndex={0} className="periscope-btn primary">
+					Return To Home
+				</Button>
 			</Space>
 		</Container>
 	);

frontend/src/providers/App/App.tsx

@@ -19,12 +19,6 @@ import getUserVersion from 'api/v1/version/get';
 import { LOCALSTORAGE } from 'constants/localStorage';
 import dayjs from 'dayjs';
 import useActiveLicenseV3 from 'hooks/useActiveLicenseV3/useActiveLicenseV3';
-import {
-	IsAdminPermission,
-	IsEditorPermission,
-	IsViewerPermission,
-} from 'hooks/useAuthZ/legacy';
-import { useAuthZ } from 'hooks/useAuthZ/useAuthZ';
 import { useGetFeatureFlag } from 'hooks/useGetFeatureFlag';
 import { useGlobalEventListener } from 'hooks/useGlobalEventListener';
 import { ChangelogSchema } from 'types/api/changelog/getChangelogByVersion';
@@ -40,7 +34,7 @@ import {
 	UserPreference,
 } from 'types/api/preferences/preference';
 import { Organization } from 'types/api/user/getOrganization';
-import { ROLES, USER_ROLES } from 'types/roles';
+import { USER_ROLES } from 'types/roles';
 
 import { IAppContext, IUser } from './types';
 import { getUserDefaults } from './utils';
@@ -49,7 +43,7 @@ export const AppContext = createContext<IAppContext | undefined>(undefined);
 
 export function AppProvider({ children }: PropsWithChildren): JSX.Element {
 	// on load of the provider set the user defaults with access token , refresh token from local storage
-	const [defaultUser, setDefaultUser] = useState<IUser>(() => getUserDefaults());
+	const [user, setUser] = useState<IUser>(() => getUserDefaults());
 	const [activeLicense, setActiveLicense] = useState<LicenseResModel | null>(
 		null,
 	);
@@ -76,51 +70,18 @@ export function AppProvider({ children }: PropsWithChildren): JSX.Element {
 	// if logged out and trying to hit any route none of these calls will trigger
 	const {
 		data: userData,
-		isFetching: isFetchingUserData,
-		error: userFetchDataError,
+		isFetching: isFetchingUser,
+		error: userFetchError,
 	} = useQuery({
 		queryFn: get,
 		queryKey: ['/api/v1/user/me'],
 		enabled: isLoggedIn,
 	});
 
-	const {
-		permissions: permissionsResult,
-		isFetching: isFetchingPermissions,
-		error: errorOnPermissions,
-		refetchPermissions,
-	} = useAuthZ([IsAdminPermission, IsEditorPermission, IsViewerPermission], {
-		enabled: isLoggedIn,
-	});
-
-	const isFetchingUser = isFetchingUserData || isFetchingPermissions;
-	const userFetchError = userFetchDataError || errorOnPermissions;
-
-	const userRole = useMemo(() => {
-		if (permissionsResult?.[IsAdminPermission]?.isGranted) {
-			return USER_ROLES.ADMIN;
-		}
-		if (permissionsResult?.[IsEditorPermission]?.isGranted) {
-			return USER_ROLES.EDITOR;
-		}
-		if (permissionsResult?.[IsViewerPermission]?.isGranted) {
-			return USER_ROLES.VIEWER;
-		}
-		// if none of the permissions, so anonymous
-		return USER_ROLES.ANONYMOUS;
-	}, [permissionsResult]);
-
-	const user: IUser = useMemo(() => {
-		return {
-			...defaultUser,
-			role: userRole as ROLES,
-		};
-	}, [defaultUser, userRole]);
-
 	useEffect(() => {
 		if (!isFetchingUser && userData && userData.data) {
 			setLocalStorageApi(LOCALSTORAGE.LOGGED_IN_USER_EMAIL, userData.data.email);
-			setDefaultUser((prev) => ({
+			setUser((prev) => ({
 				...prev,
 				...userData.data,
 			}));
@@ -242,7 +203,7 @@ export function AppProvider({ children }: PropsWithChildren): JSX.Element {
 	}, [userPreferencesData, isFetchingUserPreferences, isLoggedIn]);
 
 	function updateUser(user: IUser): void {
-		setDefaultUser((prev) => ({
+		setUser((prev) => ({
 			...prev,
 			...user,
 		}));
@@ -283,7 +244,7 @@ export function AppProvider({ children }: PropsWithChildren): JSX.Element {
 					...org.slice(orgIndex + 1, org.length),
 				];
 				setOrg(updatedOrg);
-				setDefaultUser((prev) => {
+				setUser((prev) => {
 					if (prev.orgId === orgId) {
 						return {
 							...prev,
@@ -311,7 +272,7 @@ export function AppProvider({ children }: PropsWithChildren): JSX.Element {
 	// global event listener for AFTER_LOGIN event to start the user fetch post all actions are complete
 	useGlobalEventListener('AFTER_LOGIN', (event) => {
 		if (event.detail) {
-			setDefaultUser((prev) => ({
+			setUser((prev) => ({
 				...prev,
 				accessJwt: event.detail.accessJWT,
 				refreshJwt: event.detail.refreshJWT,
@@ -319,14 +280,12 @@ export function AppProvider({ children }: PropsWithChildren): JSX.Element {
 			}));
 			setIsLoggedIn(true);
 		}
-
-		refetchPermissions();
 	});
 
 	// global event listener for LOGOUT event to clean the app context state
 	useGlobalEventListener('LOGOUT', () => {
 		setIsLoggedIn(false);
-		setDefaultUser(getUserDefaults());
+		setUser(getUserDefaults());
 		setActiveLicense(null);
 		setTrialInfo(null);
 		setFeatureFlags(null);

frontend/src/providers/App/__tests__/App.test.tsx

@@ -1,273 +0,0 @@
-import { ReactElement } from 'react';
-import { QueryClient, QueryClientProvider } from 'react-query';
-import { renderHook, waitFor } from '@testing-library/react';
-import setLocalStorageApi from 'api/browser/localstorage/set';
-import {
-	AuthtypesGettableTransactionDTO,
-	AuthtypesTransactionDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { LOCALSTORAGE } from 'constants/localStorage';
-import { SINGLE_FLIGHT_WAIT_TIME_MS } from 'hooks/useAuthZ/constants';
-import { server } from 'mocks-server/server';
-import { rest } from 'msw';
-import { USER_ROLES } from 'types/roles';
-
-import { AppProvider, useAppContext } from '../App';
-
-const AUTHZ_CHECK_URL = 'http://localhost/api/v1/authz/check';
-
-jest.mock('constants/env', () => ({
-	ENVIRONMENT: { baseURL: 'http://localhost', wsURL: '' },
-}));
-
-/**
- * Since we are mocking the check permissions, this is needed
- */
-const waitForSinglePreflightToFinish = async (): Promise<void> =>
-	await new Promise((r) => setTimeout(r, SINGLE_FLIGHT_WAIT_TIME_MS));
-
-function authzMockResponse(
-	payload: AuthtypesTransactionDTO[],
-	authorizedByIndex: boolean[],
-): { data: AuthtypesGettableTransactionDTO[]; status: string } {
-	return {
-		data: payload.map((txn, i) => ({
-			relation: txn.relation,
-			object: txn.object,
-			authorized: authorizedByIndex[i] ?? false,
-		})),
-		status: 'success',
-	};
-}
-
-const queryClient = new QueryClient({
-	defaultOptions: {
-		queries: {
-			refetchOnWindowFocus: false,
-			retry: false,
-		},
-	},
-});
-
-function createWrapper(): ({
-	children,
-}: {
-	children: ReactElement;
-}) => ReactElement {
-	return function Wrapper({
-		children,
-	}: {
-		children: ReactElement;
-	}): ReactElement {
-		return (
-			<QueryClientProvider client={queryClient}>
-				<AppProvider>{children}</AppProvider>
-			</QueryClientProvider>
-		);
-	};
-}
-
-describe('AppProvider user.role from permissions', () => {
-	beforeEach(() => {
-		queryClient.clear();
-		setLocalStorageApi(LOCALSTORAGE.IS_LOGGED_IN, 'true');
-	});
-
-	it('sets user.role to ADMIN and hasEditPermission to true when admin permission is granted', async () => {
-		server.use(
-			rest.post(AUTHZ_CHECK_URL, async (req, res, ctx) => {
-				const payload = await req.json();
-				return res(
-					ctx.status(200),
-					ctx.json(authzMockResponse(payload, [true, false, false])),
-				);
-			}),
-		);
-
-		const wrapper = createWrapper();
-		const { result } = renderHook(() => useAppContext(), { wrapper });
-
-		await waitForSinglePreflightToFinish();
-
-		await waitFor(
-			() => {
-				expect(result.current.user.role).toBe(USER_ROLES.ADMIN);
-				expect(result.current.hasEditPermission).toBe(true);
-			},
-			{ timeout: 2000 },
-		);
-	});
-
-	it('sets user.role to EDITOR and hasEditPermission to true when only editor permission is granted', async () => {
-		server.use(
-			rest.post(AUTHZ_CHECK_URL, async (req, res, ctx) => {
-				const payload = await req.json();
-				return res(
-					ctx.status(200),
-					ctx.json(authzMockResponse(payload, [false, true, false])),
-				);
-			}),
-		);
-
-		const wrapper = createWrapper();
-		const { result } = renderHook(() => useAppContext(), { wrapper });
-
-		await waitForSinglePreflightToFinish();
-
-		await waitFor(
-			() => {
-				expect(result.current.user.role).toBe(USER_ROLES.EDITOR);
-				expect(result.current.hasEditPermission).toBe(true);
-			},
-			{ timeout: 2000 },
-		);
-	});
-
-	it('sets user.role to VIEWER and hasEditPermission to false when only viewer permission is granted', async () => {
-		server.use(
-			rest.post(AUTHZ_CHECK_URL, async (req, res, ctx) => {
-				const payload = await req.json();
-				return res(
-					ctx.status(200),
-					ctx.json(authzMockResponse(payload, [false, false, true])),
-				);
-			}),
-		);
-
-		const wrapper = createWrapper();
-		const { result } = renderHook(() => useAppContext(), { wrapper });
-
-		await waitForSinglePreflightToFinish();
-
-		await waitFor(
-			() => {
-				expect(result.current.user.role).toBe(USER_ROLES.VIEWER);
-				expect(result.current.hasEditPermission).toBe(false);
-			},
-			{ timeout: 2000 },
-		);
-	});
-
-	it('sets user.role to ANONYMOUS and hasEditPermission to false when no role permission is granted', async () => {
-		server.use(
-			rest.post(AUTHZ_CHECK_URL, async (req, res, ctx) => {
-				const payload = await req.json();
-				return res(
-					ctx.status(200),
-					ctx.json(authzMockResponse(payload, [false, false, false])),
-				);
-			}),
-		);
-
-		const wrapper = createWrapper();
-		const { result } = renderHook(() => useAppContext(), { wrapper });
-
-		await waitForSinglePreflightToFinish();
-
-		await waitFor(
-			() => {
-				expect(result.current.user.role).toBe(USER_ROLES.ANONYMOUS);
-				expect(result.current.hasEditPermission).toBe(false);
-			},
-			{ timeout: 2000 },
-		);
-	});
-
-	/**
-	 * This is expected to not happen, but we'll test it just in case.
-	 */
-	describe('when multiple role permissions are granted', () => {
-		it('prefers ADMIN over EDITOR and VIEWER when multiple role permissions are granted', async () => {
-			server.use(
-				rest.post(AUTHZ_CHECK_URL, async (req, res, ctx) => {
-					const payload = await req.json();
-					return res(
-						ctx.status(200),
-						ctx.json(authzMockResponse(payload, [true, true, true])),
-					);
-				}),
-			);
-
-			const wrapper = createWrapper();
-			const { result } = renderHook(() => useAppContext(), { wrapper });
-
-			await waitFor(
-				() => {
-					expect(result.current.user.role).toBe(USER_ROLES.ADMIN);
-					expect(result.current.hasEditPermission).toBe(true);
-				},
-				{ timeout: 300 },
-			);
-		});
-
-		it('prefers EDITOR over VIEWER when editor and viewer permissions are granted', async () => {
-			server.use(
-				rest.post(AUTHZ_CHECK_URL, async (req, res, ctx) => {
-					const payload = await req.json();
-					return res(
-						ctx.status(200),
-						ctx.json(authzMockResponse(payload, [false, true, true])),
-					);
-				}),
-			);
-
-			const wrapper = createWrapper();
-			const { result } = renderHook(() => useAppContext(), { wrapper });
-
-			await waitForSinglePreflightToFinish();
-
-			await waitFor(
-				() => {
-					expect(result.current.user.role).toBe(USER_ROLES.EDITOR);
-					expect(result.current.hasEditPermission).toBe(true);
-				},
-				{ timeout: 2000 },
-			);
-		});
-	});
-});
-
-describe('AppProvider when authz/check fails', () => {
-	beforeEach(() => {
-		queryClient.clear();
-		setLocalStorageApi(LOCALSTORAGE.IS_LOGGED_IN, 'true');
-	});
-
-	it('sets userFetchError when authz/check returns 500 (same as user fetch error)', async () => {
-		server.use(
-			rest.post(AUTHZ_CHECK_URL, (_, res, ctx) =>
-				res(ctx.status(500), ctx.json({ error: 'Internal Server Error' })),
-			),
-		);
-
-		const wrapper = createWrapper();
-		const { result } = renderHook(() => useAppContext(), { wrapper });
-
-		await waitForSinglePreflightToFinish();
-
-		await waitFor(
-			() => {
-				expect(result.current.userFetchError).toBeTruthy();
-			},
-			{ timeout: 2000 },
-		);
-	});
-
-	it('sets userFetchError when authz/check fails with network error (same as user fetch error)', async () => {
-		server.use(
-			rest.post(AUTHZ_CHECK_URL, (_, res) => res.networkError('Network error')),
-		);
-
-		const wrapper = createWrapper();
-		const { result } = renderHook(() => useAppContext(), { wrapper });
-
-		await waitForSinglePreflightToFinish();
-
-		await waitFor(
-			() => {
-				expect(result.current.userFetchError).toBeTruthy();
-			},
-			{ timeout: 2000 },
-		);
-	});
-});

frontend/src/types/api/dashboard/getAll.ts

@@ -141,7 +141,6 @@ export interface IBaseWidget {
 	showPoints?: boolean;
 	lineStyle?: LineStyle;
 	fillMode?: FillMode;
-	spanGaps?: boolean | number;
 }
 export interface Widgets extends IBaseWidget {
 	query: Query;

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

@@ -1,20 +0,0 @@
-import { UserResponse } from './getUser';
-
-export interface Props {
-	token: string;
-	password: string;
-	displayName?: string;
-	sourceUrl?: string;
-}
-
-export interface LoginPrecheckResponse {
-	sso: boolean;
-	ssoUrl?: string;
-	canSelfRegister?: boolean;
-	isUser: boolean;
-}
-
-export interface PayloadProps {
-	data: UserResponse;
-	status: string;
-}

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

@@ -1,7 +0,0 @@
-export interface Props {
-	id: string;
-}
-
-export interface PayloadProps {
-	data: string;
-}

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

@@ -1,22 +0,0 @@
-import { User } from 'types/reducer/app';
-import { ROLES } from 'types/roles';
-
-import { Organization } from './getOrganization';
-
-export interface Props {
-	inviteId: string;
-}
-
-export interface PayloadProps {
-	data: InviteDetails;
-	status: string;
-}
-
-export interface InviteDetails {
-	createdAt: number;
-	email: User['email'];
-	name: User['displayName'];
-	role: ROLES;
-	token: string;
-	organization: Organization['displayName'];
-}

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

@@ -1,16 +0,0 @@
-import { User } from 'types/reducer/app';
-import { ROLES } from 'types/roles';
-
-export interface PendingInvite {
-	createdAt: number;
-	email: User['email'];
-	name: User['displayName'];
-	role: ROLES;
-	id: string;
-	token: string;
-}
-
-export type PayloadProps = {
-	data: PendingInvite[];
-	status: string;
-};

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

@@ -7,17 +7,16 @@ export interface Props {
 }
 
 export interface UserResponse {
-	createdAt: number;
+	createdAt: number | string;
 	email: string;
 	id: string;
 	displayName: string;
 	orgId: string;
 	organization: string;
-	/**
-	 * @deprecated This will be removed in the future releases in favor of new AuthZ framework
-	 */
 	role: ROLES;
-	updatedAt?: number;
+	updatedAt?: number | string;
+	isRoot?: boolean;
+	status?: 'active' | 'pending_invite' | 'deleted';
 }
 export interface PayloadProps {
 	data: UserResponse;

frontend/src/types/roles.ts

@@ -2,16 +2,14 @@ export type ADMIN = 'ADMIN';
 export type VIEWER = 'VIEWER';
 export type EDITOR = 'EDITOR';
 export type AUTHOR = 'AUTHOR';
-export type ANONYMOUS = 'ANONYMOUS';
 
-export type ROLES = ADMIN | VIEWER | EDITOR | AUTHOR | ANONYMOUS;
+export type ROLES = ADMIN | VIEWER | EDITOR | AUTHOR;
 
 export const USER_ROLES = {
 	ADMIN: 'ADMIN',
 	VIEWER: 'VIEWER',
 	EDITOR: 'EDITOR',
 	AUTHOR: 'AUTHOR',
-	ANONYMOUS: 'ANONYMOUS',
 };
 
 export enum RoleType {

frontend/src/utils/permission/index.ts

@@ -69,7 +69,7 @@ export const routePermission: Record<keyof typeof ROUTES, ROLES[]> = {
 	ALERT_OVERVIEW: ['ADMIN', 'EDITOR', 'VIEWER'],
 	LOGIN: ['ADMIN', 'EDITOR', 'VIEWER'],
 	FORGOT_PASSWORD: ['ADMIN', 'EDITOR', 'VIEWER'],
-	NOT_FOUND: ['ADMIN', 'VIEWER', 'EDITOR', 'ANONYMOUS'],
+	NOT_FOUND: ['ADMIN', 'VIEWER', 'EDITOR'],
 	PASSWORD_RESET: ['ADMIN', 'EDITOR', 'VIEWER'],
 	SERVICE_METRICS: ['ADMIN', 'EDITOR', 'VIEWER'],
 	SETTINGS: ['ADMIN', 'EDITOR', 'VIEWER'],
@@ -77,7 +77,7 @@ export const routePermission: Record<keyof typeof ROUTES, ROLES[]> = {
 	TRACES_EXPLORER: ['ADMIN', 'EDITOR', 'VIEWER'],
 	TRACE: ['ADMIN', 'EDITOR', 'VIEWER'],
 	TRACE_DETAIL: ['ADMIN', 'EDITOR', 'VIEWER'],
-	UN_AUTHORIZED: ['ADMIN', 'EDITOR', 'VIEWER', 'ANONYMOUS'],
+	UN_AUTHORIZED: ['ADMIN', 'EDITOR', 'VIEWER'],
 	USAGE_EXPLORER: ['ADMIN', 'EDITOR', 'VIEWER'],
 	VERSION: ['ADMIN', 'EDITOR', 'VIEWER'],
 	LOGS: ['ADMIN', 'EDITOR', 'VIEWER'],
@@ -101,7 +101,7 @@ export const routePermission: Record<keyof typeof ROUTES, ROLES[]> = {
 	ROLE_DETAILS: ['ADMIN'],
 	MEMBERS_SETTINGS: ['ADMIN'],
 	BILLING: ['ADMIN'],
-	SUPPORT: ['ADMIN', 'EDITOR', 'VIEWER', 'ANONYMOUS'],
+	SUPPORT: ['ADMIN', 'EDITOR', 'VIEWER'],
 	SOMETHING_WENT_WRONG: ['ADMIN', 'EDITOR', 'VIEWER'],
 	LOGS_SAVE_VIEWS: ['ADMIN', 'EDITOR', 'VIEWER'],
 	TRACES_SAVE_VIEWS: ['ADMIN', 'EDITOR', 'VIEWER'],

pkg/apiserver/signozapiserver/gateway.go

@@ -10,7 +10,7 @@ import (
 )
 
 func (provider *provider) addGatewayRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v2/gateway/ingestion_keys", handler.New(provider.authZ.EditAccess(provider.gatewayHandler.GetIngestionKeys), handler.OpenAPIDef{
+	if err := router.Handle("/api/v2/gateway/ingestion_keys", handler.New(provider.authZ.AdminAccess(provider.gatewayHandler.GetIngestionKeys), handler.OpenAPIDef{
 		ID:                  "GetIngestionKeys",
 		Tags:                []string{"gateway"},
 		Summary:             "Get ingestion keys for workspace",
@@ -23,12 +23,12 @@ func (provider *provider) addGatewayRoutes(router *mux.Router) error {
 		SuccessStatusCode:   http.StatusOK,
 		ErrorStatusCodes:    []int{},
 		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
 	})).Methods(http.MethodGet).GetError(); err != nil {
 		return err
 	}
 
-	if err := router.Handle("/api/v2/gateway/ingestion_keys/search", handler.New(provider.authZ.EditAccess(provider.gatewayHandler.SearchIngestionKeys), handler.OpenAPIDef{
+	if err := router.Handle("/api/v2/gateway/ingestion_keys/search", handler.New(provider.authZ.AdminAccess(provider.gatewayHandler.SearchIngestionKeys), handler.OpenAPIDef{
 		ID:                  "SearchIngestionKeys",
 		Tags:                []string{"gateway"},
 		Summary:             "Search ingestion keys for workspace",
@@ -41,12 +41,12 @@ func (provider *provider) addGatewayRoutes(router *mux.Router) error {
 		SuccessStatusCode:   http.StatusOK,
 		ErrorStatusCodes:    []int{},
 		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
 	})).Methods(http.MethodGet).GetError(); err != nil {
 		return err
 	}
 
-	if err := router.Handle("/api/v2/gateway/ingestion_keys", handler.New(provider.authZ.EditAccess(provider.gatewayHandler.CreateIngestionKey), handler.OpenAPIDef{
+	if err := router.Handle("/api/v2/gateway/ingestion_keys", handler.New(provider.authZ.AdminAccess(provider.gatewayHandler.CreateIngestionKey), handler.OpenAPIDef{
 		ID:                  "CreateIngestionKey",
 		Tags:                []string{"gateway"},
 		Summary:             "Create ingestion key for workspace",
@@ -58,12 +58,12 @@ func (provider *provider) addGatewayRoutes(router *mux.Router) error {
 		SuccessStatusCode:   http.StatusCreated,
 		ErrorStatusCodes:    []int{},
 		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
 	})).Methods(http.MethodPost).GetError(); err != nil {
 		return err
 	}
 
-	if err := router.Handle("/api/v2/gateway/ingestion_keys/{keyId}", handler.New(provider.authZ.EditAccess(provider.gatewayHandler.UpdateIngestionKey), handler.OpenAPIDef{
+	if err := router.Handle("/api/v2/gateway/ingestion_keys/{keyId}", handler.New(provider.authZ.AdminAccess(provider.gatewayHandler.UpdateIngestionKey), handler.OpenAPIDef{
 		ID:                  "UpdateIngestionKey",
 		Tags:                []string{"gateway"},
 		Summary:             "Update ingestion key for workspace",
@@ -75,12 +75,12 @@ func (provider *provider) addGatewayRoutes(router *mux.Router) error {
 		SuccessStatusCode:   http.StatusNoContent,
 		ErrorStatusCodes:    []int{},
 		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
 	})).Methods(http.MethodPatch).GetError(); err != nil {
 		return err
 	}
 
-	if err := router.Handle("/api/v2/gateway/ingestion_keys/{keyId}", handler.New(provider.authZ.EditAccess(provider.gatewayHandler.DeleteIngestionKey), handler.OpenAPIDef{
+	if err := router.Handle("/api/v2/gateway/ingestion_keys/{keyId}", handler.New(provider.authZ.AdminAccess(provider.gatewayHandler.DeleteIngestionKey), handler.OpenAPIDef{
 		ID:                  "DeleteIngestionKey",
 		Tags:                []string{"gateway"},
 		Summary:             "Delete ingestion key for workspace",
@@ -92,12 +92,12 @@ func (provider *provider) addGatewayRoutes(router *mux.Router) error {
 		SuccessStatusCode:   http.StatusNoContent,
 		ErrorStatusCodes:    []int{},
 		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
 	})).Methods(http.MethodDelete).GetError(); err != nil {
 		return err
 	}
 
-	if err := router.Handle("/api/v2/gateway/ingestion_keys/{keyId}/limits", handler.New(provider.authZ.EditAccess(provider.gatewayHandler.CreateIngestionKeyLimit), handler.OpenAPIDef{
+	if err := router.Handle("/api/v2/gateway/ingestion_keys/{keyId}/limits", handler.New(provider.authZ.AdminAccess(provider.gatewayHandler.CreateIngestionKeyLimit), handler.OpenAPIDef{
 		ID:                  "CreateIngestionKeyLimit",
 		Tags:                []string{"gateway"},
 		Summary:             "Create limit for the ingestion key",
@@ -109,12 +109,12 @@ func (provider *provider) addGatewayRoutes(router *mux.Router) error {
 		SuccessStatusCode:   http.StatusCreated,
 		ErrorStatusCodes:    []int{},
 		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
 	})).Methods(http.MethodPost).GetError(); err != nil {
 		return err
 	}
 
-	if err := router.Handle("/api/v2/gateway/ingestion_keys/limits/{limitId}", handler.New(provider.authZ.EditAccess(provider.gatewayHandler.UpdateIngestionKeyLimit), handler.OpenAPIDef{
+	if err := router.Handle("/api/v2/gateway/ingestion_keys/limits/{limitId}", handler.New(provider.authZ.AdminAccess(provider.gatewayHandler.UpdateIngestionKeyLimit), handler.OpenAPIDef{
 		ID:                  "UpdateIngestionKeyLimit",
 		Tags:                []string{"gateway"},
 		Summary:             "Update limit for the ingestion key",
@@ -126,12 +126,12 @@ func (provider *provider) addGatewayRoutes(router *mux.Router) error {
 		SuccessStatusCode:   http.StatusNoContent,
 		ErrorStatusCodes:    []int{},
 		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
 	})).Methods(http.MethodPatch).GetError(); err != nil {
 		return err
 	}
 
-	if err := router.Handle("/api/v2/gateway/ingestion_keys/limits/{limitId}", handler.New(provider.authZ.EditAccess(provider.gatewayHandler.DeleteIngestionKeyLimit), handler.OpenAPIDef{
+	if err := router.Handle("/api/v2/gateway/ingestion_keys/limits/{limitId}", handler.New(provider.authZ.AdminAccess(provider.gatewayHandler.DeleteIngestionKeyLimit), handler.OpenAPIDef{
 		ID:                  "DeleteIngestionKeyLimit",
 		Tags:                []string{"gateway"},
 		Summary:             "Delete limit for the ingestion key",
@@ -143,7 +143,7 @@ func (provider *provider) addGatewayRoutes(router *mux.Router) error {
 		SuccessStatusCode:   http.StatusNoContent,
 		ErrorStatusCodes:    []int{},
 		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
+		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
 	})).Methods(http.MethodDelete).GetError(); err != nil {
 		return err
 	}

pkg/apiserver/signozapiserver/global.go

@@ -4,24 +4,24 @@ import (
 	"net/http"
 
 	"github.com/SigNoz/signoz/pkg/http/handler"
-	"github.com/SigNoz/signoz/pkg/types/globaltypes"
+	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/gorilla/mux"
 )
 
 func (provider *provider) addGlobalRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v1/global/config", handler.New(provider.authZ.OpenAccess(provider.globalHandler.GetConfig), handler.OpenAPIDef{
+	if err := router.Handle("/api/v1/global/config", handler.New(provider.authZ.EditAccess(provider.globalHandler.GetConfig), handler.OpenAPIDef{
 		ID:                  "GetGlobalConfig",
 		Tags:                []string{"global"},
 		Summary:             "Get global config",
 		Description:         "This endpoint returns global config",
 		Request:             nil,
 		RequestContentType:  "",
-		Response:            new(globaltypes.Config),
+		Response:            new(types.GettableGlobalConfig),
 		ResponseContentType: "application/json",
 		SuccessStatusCode:   http.StatusOK,
 		ErrorStatusCodes:    []int{},
 		Deprecated:          false,
-		SecuritySchemes:     nil,
+		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
 	})).Methods(http.MethodGet).GetError(); err != nil {
 		return err
 	}

pkg/apiserver/signozapiserver/provider.go

@@ -238,7 +238,7 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 
 func newSecuritySchemes(role types.Role) []handler.OpenAPISecurityScheme {
 	return []handler.OpenAPISecurityScheme{
-		{Name: authtypes.IdentNProviderAPIKey.StringValue(), Scopes: []string{role.String()}},
+		{Name: authtypes.IdentNProviderAPIkey.StringValue(), Scopes: []string{role.String()}},
 		{Name: authtypes.IdentNProviderTokenizer.StringValue(), Scopes: []string{role.String()}},
 	}
 }

pkg/apiserver/signozapiserver/user.go

@@ -43,74 +43,6 @@ func (provider *provider) addUserRoutes(router *mux.Router) error {
 		return err
 	}
 
-	if err := router.Handle("/api/v1/invite/{token}", handler.New(provider.authZ.OpenAccess(provider.userHandler.GetInvite), handler.OpenAPIDef{
-		ID:                  "GetInvite",
-		Tags:                []string{"users"},
-		Summary:             "Get invite",
-		Description:         "This endpoint gets an invite by token",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            new(types.Invite),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
-		Deprecated:          false,
-		SecuritySchemes:     []handler.OpenAPISecurityScheme{},
-	})).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/invite/{id}", handler.New(provider.authZ.AdminAccess(provider.userHandler.DeleteInvite), handler.OpenAPIDef{
-		ID:                  "DeleteInvite",
-		Tags:                []string{"users"},
-		Summary:             "Delete invite",
-		Description:         "This endpoint deletes an invite by id",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            nil,
-		ResponseContentType: "",
-		SuccessStatusCode:   http.StatusNoContent,
-		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-	})).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/invite", handler.New(provider.authZ.AdminAccess(provider.userHandler.ListInvite), handler.OpenAPIDef{
-		ID:                  "ListInvite",
-		Tags:                []string{"users"},
-		Summary:             "List invites",
-		Description:         "This endpoint lists all invites",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            make([]*types.Invite, 0),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-	})).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/invite/accept", handler.New(provider.authZ.OpenAccess(provider.userHandler.AcceptInvite), handler.OpenAPIDef{
-		ID:                  "AcceptInvite",
-		Tags:                []string{"users"},
-		Summary:             "Accept invite",
-		Description:         "This endpoint accepts an invite by token",
-		Request:             new(types.PostableAcceptInvite),
-		RequestContentType:  "application/json",
-		Response:            new(types.User),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusCreated,
-		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
-		Deprecated:          false,
-		SecuritySchemes:     []handler.OpenAPISecurityScheme{},
-	})).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
 	if err := router.Handle("/api/v1/pats", handler.New(provider.authZ.AdminAccess(provider.userHandler.CreateAPIKey), handler.OpenAPIDef{
 		ID:                  "CreateAPIKey",
 		Tags:                []string{"users"},

pkg/global/global.go

@@ -1,14 +1,9 @@
 package global
 
-import (
-	"context"
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/types/globaltypes"
-)
+import "net/http"
 
 type Global interface {
-	GetConfig(context.Context) *globaltypes.Config
+	GetConfig() Config
 }
 
 type Handler interface {

pkg/global/signozglobal/handler.go

@@ -1,12 +1,11 @@
 package signozglobal
 
 import (
-	"context"
 	"net/http"
-	"time"
 
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/SigNoz/signoz/pkg/types"
 )
 
 type handler struct {
@@ -18,10 +17,7 @@ func NewHandler(global global.Global) global.Handler {
 }
 
 func (handler *handler) GetConfig(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
+	cfg := handler.global.GetConfig()
 
-	cfg := handler.global.GetConfig(ctx)
-
-	render.Success(rw, http.StatusOK, cfg)
+	render.Success(rw, http.StatusOK, types.NewGettableGlobalConfig(cfg.ExternalURL, cfg.IngestionURL))
 }

pkg/global/signozglobal/provider.go

@@ -5,38 +5,27 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/global"
-	"github.com/SigNoz/signoz/pkg/identn"
-	"github.com/SigNoz/signoz/pkg/types/globaltypes"
 )
 
 type provider struct {
-	config       global.Config
-	identNConfig identn.Config
-	settings     factory.ScopedProviderSettings
+	config   global.Config
+	settings factory.ScopedProviderSettings
 }
 
-func NewFactory(identNConfig identn.Config) factory.ProviderFactory[global.Global, global.Config] {
+func NewFactory() factory.ProviderFactory[global.Global, global.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("signoz"), func(ctx context.Context, providerSettings factory.ProviderSettings, config global.Config) (global.Global, error) {
-		return newProvider(ctx, providerSettings, config, identNConfig)
+		return newProvider(ctx, providerSettings, config)
 	})
 }
 
-func newProvider(_ context.Context, providerSettings factory.ProviderSettings, config global.Config, identNConfig identn.Config) (global.Global, error) {
+func newProvider(_ context.Context, providerSettings factory.ProviderSettings, config global.Config) (global.Global, error) {
 	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/global/signozglobal")
 	return &provider{
-		config:       config,
-		identNConfig: identNConfig,
-		settings:     settings,
+		config:   config,
+		settings: settings,
 	}, nil
 }
 
-func (provider *provider) GetConfig(context.Context) *globaltypes.Config {
-	return globaltypes.NewConfig(
-		globaltypes.NewEndpoint(provider.config.ExternalURL.String(), provider.config.IngestionURL.String()),
-		globaltypes.NewIdentNConfig(
-			globaltypes.TokenizerConfig{Enabled: provider.identNConfig.Tokenizer.Enabled},
-			globaltypes.APIKeyConfig{Enabled: provider.identNConfig.APIKeyConfig.Enabled},
-			globaltypes.ImpersonationConfig{Enabled: provider.identNConfig.Impersonation.Enabled},
-		),
-	)
+func (provider *provider) GetConfig() global.Config {
+	return provider.config
 }

pkg/http/middleware/authz.go

@@ -40,7 +40,7 @@ func (middleware *AuthZ) ViewAccess(next http.HandlerFunc) http.HandlerFunc {
 			return
 		}
 
-		if claims.IdentNProvider == authtypes.IdentNProviderAPIKey.StringValue() {
+		if claims.IdentNProvider == authtypes.IdentNProviderAPIkey.StringValue() {
 			if err := claims.IsViewer(); err != nil {
 				middleware.logger.WarnContext(ctx, authzDeniedMessage, "claims", claims)
 				render.Error(rw, err)
@@ -90,7 +90,7 @@ func (middleware *AuthZ) EditAccess(next http.HandlerFunc) http.HandlerFunc {
 			return
 		}
 
-		if claims.IdentNProvider == authtypes.IdentNProviderAPIKey.StringValue() {
+		if claims.IdentNProvider == authtypes.IdentNProviderAPIkey.StringValue() {
 			if err := claims.IsEditor(); err != nil {
 				middleware.logger.WarnContext(ctx, authzDeniedMessage, "claims", claims)
 				render.Error(rw, err)
@@ -139,7 +139,7 @@ func (middleware *AuthZ) AdminAccess(next http.HandlerFunc) http.HandlerFunc {
 			return
 		}
 
-		if claims.IdentNProvider == authtypes.IdentNProviderAPIKey.StringValue() {
+		if claims.IdentNProvider == authtypes.IdentNProviderAPIkey.StringValue() {
 			if err := claims.IsAdmin(); err != nil {
 				middleware.logger.WarnContext(ctx, authzDeniedMessage, "claims", claims)
 				render.Error(rw, err)

pkg/identn/apikeyidentn/identn.go

@@ -25,7 +25,7 @@ type provider struct {
 }
 
 func NewFactory(store sqlstore.SQLStore) factory.ProviderFactory[identn.IdentN, identn.Config] {
-	return factory.NewProviderFactory(factory.MustNewName(authtypes.IdentNProviderAPIKey.StringValue()), func(ctx context.Context, providerSettings factory.ProviderSettings, config identn.Config) (identn.IdentN, error) {
+	return factory.NewProviderFactory(factory.MustNewName(authtypes.IdentNProviderAPIkey.StringValue()), func(ctx context.Context, providerSettings factory.ProviderSettings, config identn.Config) (identn.IdentN, error) {
 		return New(providerSettings, store, config)
 	})
 }
@@ -40,7 +40,7 @@ func New(providerSettings factory.ProviderSettings, store sqlstore.SQLStore, con
 }
 
 func (provider *provider) Name() authtypes.IdentNProvider {
-	return authtypes.IdentNProviderAPIKey
+	return authtypes.IdentNProviderAPIkey
 }
 
 func (provider *provider) Test(req *http.Request) bool {
@@ -52,6 +52,10 @@ func (provider *provider) Test(req *http.Request) bool {
 	return false
 }
 
+func (provider *provider) Enabled() bool {
+	return provider.config.APIKeyConfig.Enabled
+}
+
 func (provider *provider) Pre(req *http.Request) *http.Request {
 	token := provider.extractToken(req)
 	if token == "" {

pkg/identn/config.go

@@ -1,7 +1,6 @@
 package identn
 
 import (
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
 )
 
@@ -11,20 +10,11 @@ type Config struct {
 
 	// Config for apikey identN resolver
 	APIKeyConfig APIKeyConfig `mapstructure:"apikey"`
-
-	// Config for impersonation identN resolver
-	Impersonation ImpersonationConfig `mapstructure:"impersonation"`
-}
-
-type ImpersonationConfig struct {
-	// Toggles the identN resolver
-	Enabled bool `mapstructure:"enabled"`
 }
 
 type TokenizerConfig struct {
 	// Toggles the identN resolver
 	Enabled bool `mapstructure:"enabled"`
-
 	// Headers to extract from incoming requests
 	Headers []string `mapstructure:"headers"`
 }
@@ -32,7 +22,6 @@ type TokenizerConfig struct {
 type APIKeyConfig struct {
 	// Toggles the identN resolver
 	Enabled bool `mapstructure:"enabled"`
-
 	// Headers to extract from incoming requests
 	Headers []string `mapstructure:"headers"`
 }
@@ -51,22 +40,9 @@ func newConfig() factory.Config {
 			Enabled: true,
 			Headers: []string{"SIGNOZ-API-KEY"},
 		},
-		Impersonation: ImpersonationConfig{
-			Enabled: false,
-		},
 	}
 }
 
 func (c Config) Validate() error {
-	if c.Impersonation.Enabled {
-		if c.Tokenizer.Enabled {
-			return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "identn::impersonation cannot be enabled if identn::tokenizer is enabled")
-		}
-
-		if c.APIKeyConfig.Enabled {
-			return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "identn::impersonation cannot be enabled if identn::apikey is enabled")
-		}
-	}
-
 	return nil
 }

pkg/identn/identn.go

@@ -23,6 +23,8 @@ type IdentN interface {
 	GetIdentity(r *http.Request) (*authtypes.Identity, error)
 
 	Name() authtypes.IdentNProvider
+
+	Enabled() bool
 }
 
 // IdentNWithPreHook is optionally implemented by resolvers that need to

pkg/identn/impersonationidentn/provider.go

@@ -1,96 +0,0 @@
-package impersonationidentn
-
-import (
-	"context"
-	"net/http"
-	"sync"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/identn"
-	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/modules/user"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-)
-
-type provider struct {
-	config     identn.Config
-	settings   factory.ScopedProviderSettings
-	orgGetter  organization.Getter
-	userGetter user.Getter
-	userConfig user.Config
-
-	mu       sync.RWMutex
-	identity *authtypes.Identity
-}
-
-func NewFactory(orgGetter organization.Getter, userGetter user.Getter, userConfig user.Config) factory.ProviderFactory[identn.IdentN, identn.Config] {
-	return factory.NewProviderFactory(factory.MustNewName(authtypes.IdentNProviderImpersonation.StringValue()), func(ctx context.Context, providerSettings factory.ProviderSettings, config identn.Config) (identn.IdentN, error) {
-		return New(ctx, providerSettings, config, orgGetter, userGetter, userConfig)
-	})
-}
-
-func New(ctx context.Context, providerSettings factory.ProviderSettings, config identn.Config, orgGetter organization.Getter, userGetter user.Getter, userConfig user.Config) (identn.IdentN, error) {
-	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/identn/impersonationidentn")
-
-	settings.Logger().WarnContext(ctx, "impersonation identity provider is enabled, all requests will impersonate the root user")
-
-	if !userConfig.Root.Enabled {
-		return nil, errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "root user is not enabled, impersonation identity provider will not be able to resolve any identity")
-	}
-
-	return &provider{
-		config:     config,
-		settings:   settings,
-		orgGetter:  orgGetter,
-		userGetter: userGetter,
-		userConfig: userConfig,
-	}, nil
-}
-
-func (provider *provider) Name() authtypes.IdentNProvider {
-	return authtypes.IdentNProviderImpersonation
-}
-
-func (provider *provider) Test(_ *http.Request) bool {
-	return true
-}
-
-func (provider *provider) GetIdentity(req *http.Request) (*authtypes.Identity, error) {
-	ctx := req.Context()
-
-	provider.mu.RLock()
-	if provider.identity != nil {
-		provider.mu.RUnlock()
-		return provider.identity, nil
-	}
-	provider.mu.RUnlock()
-
-	provider.mu.Lock()
-	defer provider.mu.Unlock()
-
-	// Re-check after acquiring write lock; another goroutine may have resolved it.
-	if provider.identity != nil {
-		return provider.identity, nil
-	}
-
-	org, _, err := provider.orgGetter.GetByIDOrName(ctx, provider.userConfig.Root.Org.ID, provider.userConfig.Root.Org.Name)
-	if err != nil {
-		return nil, err
-	}
-
-	rootUser, err := provider.userGetter.GetRootUserByOrgID(ctx, org.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	provider.identity = authtypes.NewIdentity(
-		rootUser.ID,
-		rootUser.OrgID,
-		rootUser.Email,
-		rootUser.Role,
-		authtypes.IdentNProviderImpersonation,
-	)
-
-	return provider.identity, nil
-}

pkg/identn/resolver.go

@@ -1,11 +1,9 @@
 package identn
 
 import (
-	"context"
 	"net/http"
 
 	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
 )
 
 type identNResolver struct {
@@ -13,55 +11,19 @@ type identNResolver struct {
 	settings factory.ScopedProviderSettings
 }
 
-func NewIdentNResolver(ctx context.Context, providerSettings factory.ProviderSettings, identNConfig Config, identNFactories factory.NamedMap[factory.ProviderFactory[IdentN, Config]]) (IdentNResolver, error) {
-	identNs := []IdentN{}
+func NewIdentNResolver(providerSettings factory.ProviderSettings, identNs ...IdentN) IdentNResolver {
+	enabledIdentNs := []IdentN{}
 
-	if identNConfig.Impersonation.Enabled {
-		identNFactory, err := identNFactories.Get(authtypes.IdentNProviderImpersonation.StringValue())
-		if err != nil {
-			return nil, err
+	for _, identN := range identNs {
+		if identN.Enabled() {
+			enabledIdentNs = append(enabledIdentNs, identN)
 		}
-
-		identN, err := identNFactory.New(ctx, providerSettings, identNConfig)
-		if err != nil {
-			return nil, err
-		}
-
-		identNs = append(identNs, identN)
-	}
-
-	if identNConfig.Tokenizer.Enabled {
-		identNFactory, err := identNFactories.Get(authtypes.IdentNProviderTokenizer.StringValue())
-		if err != nil {
-			return nil, err
-		}
-
-		identN, err := identNFactory.New(ctx, providerSettings, identNConfig)
-		if err != nil {
-			return nil, err
-		}
-
-		identNs = append(identNs, identN)
-	}
-
-	if identNConfig.APIKeyConfig.Enabled {
-		identNFactory, err := identNFactories.Get(authtypes.IdentNProviderAPIKey.StringValue())
-		if err != nil {
-			return nil, err
-		}
-
-		identN, err := identNFactory.New(ctx, providerSettings, identNConfig)
-		if err != nil {
-			return nil, err
-		}
-
-		identNs = append(identNs, identN)
 	}
 
 	return &identNResolver{
-		identNs:  identNs,
+		identNs:  enabledIdentNs,
 		settings: factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/identn"),
-	}, nil
+	}
 }
 
 // GetIdentN returns the first IdentN whose Test() returns true.

pkg/identn/tokenizeridentn/identn.go

@@ -48,6 +48,10 @@ func (provider *provider) Test(req *http.Request) bool {
 	return false
 }
 
+func (provider *provider) Enabled() bool {
+	return provider.config.Tokenizer.Enabled
+}
+
 func (provider *provider) Pre(req *http.Request) *http.Request {
 	accessToken := provider.extractToken(req)
 	if accessToken == "" {

pkg/modules/organization/implorganization/getter.go

@@ -3,7 +3,6 @@ package implorganization
 import (
 	"context"
 
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/sharder"
 	"github.com/SigNoz/signoz/pkg/types"
@@ -23,33 +22,6 @@ func (module *getter) Get(ctx context.Context, id valuer.UUID) (*types.Organizat
 	return module.store.Get(ctx, id)
 }
 
-func (module *getter) GetByIDOrName(ctx context.Context, id valuer.UUID, name string) (*types.Organization, bool, error) {
-	if id.IsZero() {
-		org, err := module.store.GetByName(ctx, name)
-		if err != nil {
-			return nil, false, err
-		}
-
-		return org, true, nil
-	}
-
-	org, err := module.store.Get(ctx, id)
-	if err == nil {
-		return org, false, nil
-	}
-
-	if !errors.Ast(err, errors.TypeNotFound) {
-		return nil, false, err
-	}
-
-	org, err = module.store.GetByName(ctx, name)
-	if err != nil {
-		return nil, false, err
-	}
-
-	return org, true, nil
-}
-
 func (module *getter) ListByOwnedKeyRange(ctx context.Context) ([]*types.Organization, error) {
 	start, end, err := module.sharder.GetMyOwnedKeyRange(ctx)
 	if err != nil {

pkg/modules/organization/organization.go

@@ -12,10 +12,6 @@ type Getter interface {
 	// Get gets the organization based on the given id
 	Get(context.Context, valuer.UUID) (*types.Organization, error)
 
-	// GetByIDOrName gets the organization by id, falling back to name on not found.
-	// The boolean is true when the name fallback path was used.
-	GetByIDOrName(context.Context, valuer.UUID, string) (*types.Organization, bool, error)
-
 	// ListByOwnedKeyRange gets all the organizations owned by the instance
 	ListByOwnedKeyRange(context.Context) ([]*types.Organization, error)
 

pkg/modules/user/impluser/handler.go

@@ -27,25 +27,6 @@ func NewHandler(module root.Module, getter root.Getter) root.Handler {
 	return &handler{module: module, getter: getter}
 }
 
-func (h *handler) AcceptInvite(w http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	req := new(types.PostableAcceptInvite)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	user, err := h.module.AcceptInvite(ctx, req.InviteToken, req.Password)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	render.Success(w, http.StatusCreated, user)
-}
-
 func (h *handler) CreateInvite(rw http.ResponseWriter, r *http.Request) {
 	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
 	defer cancel()
@@ -104,59 +85,6 @@ func (h *handler) CreateBulkInvite(rw http.ResponseWriter, r *http.Request) {
 	render.Success(rw, http.StatusCreated, nil)
 }
 
-func (h *handler) GetInvite(w http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	token := mux.Vars(r)["token"]
-	invite, err := h.module.GetInviteByToken(ctx, token)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	render.Success(w, http.StatusOK, invite)
-}
-
-func (h *handler) ListInvite(w 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(w, err)
-		return
-	}
-
-	invites, err := h.module.ListInvite(ctx, claims.OrgID)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	render.Success(w, http.StatusOK, invites)
-}
-
-func (h *handler) DeleteInvite(w http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	id := mux.Vars(r)["id"]
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	if err := h.module.DeleteUser(ctx, valuer.MustNewUUID(claims.OrgID), id, claims.UserID); err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	render.Success(w, http.StatusNoContent, nil)
-}
-
 func (h *handler) GetUser(w http.ResponseWriter, r *http.Request) {
 	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
 	defer cancel()
@@ -213,9 +141,6 @@ func (h *handler) ListUsers(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// temp code - show only active users
-	users = slices.DeleteFunc(users, func(user *types.User) bool { return user.Status != types.UserStatusActive })
-
 	render.Success(w, http.StatusOK, users)
 }
 

pkg/modules/user/impluser/module.go

@@ -49,54 +49,6 @@ func NewModule(store types.UserStore, tokenizer tokenizer.Tokenizer, emailing em
 	}
 }
 
-func (m *Module) AcceptInvite(ctx context.Context, token string, password string) (*types.User, error) {
-	// get the user by reset password token
-	user, err := m.store.GetUserByResetPasswordToken(ctx, token)
-	if err != nil {
-		return nil, err
-	}
-
-	// update the password and delete the token
-	err = m.UpdatePasswordByResetPasswordToken(ctx, token, password)
-	if err != nil {
-		return nil, err
-	}
-
-	// query the user again
-	user, err = m.store.GetByOrgIDAndID(ctx, user.OrgID, user.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	return user, nil
-}
-
-func (m *Module) GetInviteByToken(ctx context.Context, token string) (*types.Invite, error) {
-	// get the user
-	user, err := m.store.GetUserByResetPasswordToken(ctx, token)
-	if err != nil {
-		return nil, err
-	}
-
-	// create a dummy invite obj for backward compatibility
-	invite := &types.Invite{
-		Identifiable: types.Identifiable{
-			ID: user.ID,
-		},
-		Name:  user.DisplayName,
-		Email: user.Email,
-		Token: token,
-		Role:  user.Role,
-		OrgID: user.OrgID,
-		TimeAuditable: types.TimeAuditable{
-			CreatedAt: user.CreatedAt,
-			UpdatedAt: user.UpdatedAt,
-		},
-	}
-
-	return invite, nil
-}
-
 // CreateBulk implements invite.Module.
 func (m *Module) CreateBulkInvite(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, bulkInvites *types.PostableBulkInviteRequest) ([]*types.Invite, error) {
 	creator, err := m.store.GetUser(ctx, userID)
@@ -218,46 +170,6 @@ func (m *Module) CreateBulkInvite(ctx context.Context, orgID valuer.UUID, userID
 	return invites, nil
 }
 
-func (m *Module) ListInvite(ctx context.Context, orgID string) ([]*types.Invite, error) {
-	// find all the users with pending_invite status
-	users, err := m.store.ListUsersByOrgID(ctx, valuer.MustNewUUID(orgID))
-	if err != nil {
-		return nil, err
-	}
-
-	pendingUsers := slices.DeleteFunc(users, func(user *types.User) bool { return user.Status != types.UserStatusPendingInvite })
-
-	var invites []*types.Invite
-
-	for _, pUser := range pendingUsers {
-		// get the reset password token
-		resetPasswordToken, err := m.GetOrCreateResetPasswordToken(ctx, pUser.ID)
-		if err != nil {
-			return nil, err
-		}
-
-		// create a dummy invite obj for backward compatibility
-		invite := &types.Invite{
-			Identifiable: types.Identifiable{
-				ID: pUser.ID,
-			},
-			Name:  pUser.DisplayName,
-			Email: pUser.Email,
-			Token: resetPasswordToken.Token,
-			Role:  pUser.Role,
-			OrgID: pUser.OrgID,
-			TimeAuditable: types.TimeAuditable{
-				CreatedAt: pUser.CreatedAt,
-				UpdatedAt: pUser.UpdatedAt, // dummy
-			},
-		}
-
-		invites = append(invites, invite)
-	}
-
-	return invites, nil
-}
-
 func (module *Module) CreateUser(ctx context.Context, input *types.User, opts ...root.CreateUserOption) error {
 	createUserOpts := root.NewCreateUserOptions(opts...)
 
@@ -304,10 +216,6 @@ func (m *Module) UpdateUser(ctx context.Context, orgID valuer.UUID, id string, u
 		return nil, errors.WithAdditionalf(err, "cannot update deleted user")
 	}
 
-	if err := existingUser.ErrIfPending(); err != nil {
-		return nil, errors.WithAdditionalf(err, "cannot update pending user")
-	}
-
 	requestor, err := m.store.GetUser(ctx, valuer.MustNewUUID(updatedBy))
 	if err != nil {
 		return nil, err

pkg/modules/user/impluser/service.go

@@ -77,26 +77,52 @@ func (s *service) Stop(ctx context.Context) error {
 }
 
 func (s *service) reconcile(ctx context.Context) error {
-	org, resolvedByName, err := s.orgGetter.GetByIDOrName(ctx, s.config.Org.ID, s.config.Org.Name)
+	if !s.config.Org.ID.IsZero() {
+		return s.reconcileWithOrgID(ctx)
+	}
+
+	return s.reconcileByName(ctx)
+}
+
+func (s *service) reconcileWithOrgID(ctx context.Context) error {
+	org, err := s.orgGetter.Get(ctx, s.config.Org.ID)
 	if err != nil {
 		if !errors.Ast(err, errors.TypeNotFound) {
 			return err // something really went wrong
 		}
 
-		if s.config.Org.ID.IsZero() {
-			newOrg := types.NewOrganization(s.config.Org.Name, s.config.Org.Name)
-			_, err := s.module.CreateFirstUser(ctx, newOrg, s.config.Email.String(), s.config.Email, s.config.Password)
-			return err
+		// org was not found using id check if we can find an org using name
+
+		existingOrgByName, nameErr := s.orgGetter.GetByName(ctx, s.config.Org.Name)
+		if nameErr != nil && !errors.Ast(nameErr, errors.TypeNotFound) {
+			return nameErr // something really went wrong
 		}
 
+		// we found an org using name
+		if existingOrgByName != nil {
+			// the existing org has the same name as config but org id is different inform user with actionable message
+			return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "organization with name %q already exists with a different ID %s (expected %s)", s.config.Org.Name, existingOrgByName.ID.StringValue(), s.config.Org.ID.StringValue())
+		}
+
+		// default - we did not found any org using id and name both - create a new org
 		newOrg := types.NewOrganizationWithID(s.config.Org.ID, s.config.Org.Name, s.config.Org.Name)
 		_, err = s.module.CreateFirstUser(ctx, newOrg, s.config.Email.String(), s.config.Email, s.config.Password)
 		return err
 	}
 
-	if !s.config.Org.ID.IsZero() && resolvedByName {
-		// the existing org has the same name as config but org id is different; inform user with actionable message
-		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "organization with name %q already exists with a different ID %s (expected %s)", s.config.Org.Name, org.ID.StringValue(), s.config.Org.ID.StringValue())
+	return s.reconcileRootUser(ctx, org.ID)
+}
+
+func (s *service) reconcileByName(ctx context.Context) error {
+	org, err := s.orgGetter.GetByName(ctx, s.config.Org.Name)
+	if err != nil {
+		if errors.Ast(err, errors.TypeNotFound) {
+			newOrg := types.NewOrganization(s.config.Org.Name, s.config.Org.Name)
+			_, err := s.module.CreateFirstUser(ctx, newOrg, s.config.Email.String(), s.config.Email, s.config.Password)
+			return err
+		}
+
+		return err
 	}
 
 	return s.reconcileRootUser(ctx, org.ID)

pkg/modules/user/user.go

@@ -41,9 +41,6 @@ type Module interface {
 
 	// invite
 	CreateBulkInvite(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, bulkInvites *types.PostableBulkInviteRequest) ([]*types.Invite, error)
-	ListInvite(ctx context.Context, orgID string) ([]*types.Invite, error)
-	AcceptInvite(ctx context.Context, token string, password string) (*types.User, error)
-	GetInviteByToken(ctx context.Context, token string) (*types.Invite, error)
 
 	// API KEY
 	CreateAPIKey(ctx context.Context, apiKey *types.StorableAPIKey) error
@@ -89,10 +86,6 @@ type Getter interface {
 type Handler interface {
 	// invite
 	CreateInvite(http.ResponseWriter, *http.Request)
-	AcceptInvite(http.ResponseWriter, *http.Request)
-	GetInvite(http.ResponseWriter, *http.Request) // public function
-	ListInvite(http.ResponseWriter, *http.Request)
-	DeleteInvite(http.ResponseWriter, *http.Request)
 	CreateBulkInvite(http.ResponseWriter, *http.Request)
 
 	ListUsers(http.ResponseWriter, *http.Request)