chore(codeowners): retarget the dashboard entries at their new paths

The V1 dashboard retirement moves, merges and renames most of the paths
this section names. Doing that inside the stack meant six PRs each carried
a slice of the same edit and each needed the CODEOWNERS owner's review;
collecting them here makes it one review of the whole delta.

Net effect: same team owns the same code, addressed by where it now lives.

- api/types/dashboard -> types/api/dashboard, plus the new types/api/widgets
- ListOfDashboard, NewWidget, DashboardWidget, DashboardContainer,
  GridCardLayout, PublicDashboardContainer are gone; what survives of them
  lives under container/WidgetCard
- the shared chart layer moved to lib/visualization
- DashboardPageV2 / DashboardsListPageV2 dropped their suffix

Merge this after the stack lands, so no path is left unowned in between.

Assisted-by: Claude Opus 5

.github/CODEOWNERS

@@ -152,39 +152,29 @@ go.mod @therealpandey
 
 ## Dashboard Types
 
-/frontend/src/api/types/dashboard/ @SigNoz/pulse-frontend
+/frontend/src/types/api/dashboard/ @SigNoz/pulse-frontend
+/frontend/src/types/api/widgets/ @SigNoz/pulse-frontend
 
-## Dashboard List
+## Widget Card
 
-/frontend/src/pages/DashboardsListPage/ @SigNoz/pulse-frontend
-/frontend/src/container/ListOfDashboard/ @SigNoz/pulse-frontend
-
-# Dashboard Widget Page
-
-/frontend/src/pages/DashboardWidget/ @SigNoz/pulse-frontend
-/frontend/src/container/NewWidget/ @SigNoz/pulse-frontend
-
-## Dashboard Page
-
-/frontend/src/pages/DashboardPage/ @SigNoz/pulse-frontend
-/frontend/src/container/DashboardContainer/ @SigNoz/pulse-frontend
-/frontend/src/container/GridCardLayout/ @SigNoz/pulse-frontend
+/frontend/src/container/WidgetCard/ @SigNoz/pulse-frontend
 
 ## Public Dashboard Page
 
 /frontend/src/pages/PublicDashboard/ @SigNoz/pulse-frontend
-/frontend/src/container/PublicDashboardContainer/ @SigNoz/pulse-frontend
 
 ## Dashboard Libs + Components
 
 /frontend/src/lib/uPlotV2/ @SigNoz/pulse-frontend
+/frontend/src/lib/visualization/ @SigNoz/pulse-frontend
 /frontend/src/lib/dashboard/ @SigNoz/pulse-frontend
 /frontend/src/lib/dashboardVariables/ @SigNoz/pulse-frontend
 /frontend/src/components/NewSelect/ @SigNoz/pulse-frontend
 
-## Dashboard V2
-/frontend/src/pages/DashboardPageV2/ @SigNoz/pulse-frontend
-/frontend/src/pages/DashboardsListPageV2/ @SigNoz/pulse-frontend
+## Dashboard Pages
+
+/frontend/src/pages/DashboardPage/ @SigNoz/pulse-frontend
+/frontend/src/pages/DashboardsListPage/ @SigNoz/pulse-frontend
 
 ## Infrastructure Monitoring
 /frontend/src/pages/InfrastructureMonitoring/ @SigNoz/pulse-frontend

.github/workflows/integrationci.yaml

@@ -62,7 +62,6 @@ jobs:
           - role
           - rootuser
           - savedview
-          - semconvfamilies
           - serviceaccount
           - spanmapper
           - querier_json_body

cmd/authz.go

@@ -96,7 +96,6 @@ func runGenerateAuthz(_ context.Context) error {
 		coretypes.NewResourceRef(coretypes.ResourceServiceAccount).String():                true,
 		coretypes.NewResourceRef(coretypes.ResourceRole).String():                          true,
 		coretypes.NewResourceRef(coretypes.ResourceMetaResourceFactorAPIKey).String():      true,
-		coretypes.NewResourceRef(coretypes.ResourceMetaResourceLicense).String():           true,
 		coretypes.NewResourceRef(coretypes.ResourceTelemetryResourceLogs).String():         true,
 		coretypes.NewResourceRef(coretypes.ResourceTelemetryResourceTraces).String():       true,
 		coretypes.NewResourceRef(coretypes.ResourceTelemetryResourceMetrics).String():      true,

docs/api/openapi.yml

@@ -2559,7 +2559,6 @@ components:
       - factor-api-key
       - license
       - subscription
-      - deployment-host
       - logs
       - traces
       - metrics
@@ -5642,219 +5641,6 @@ components:
       - total
       - endTimeBeforeRetention
       type: object
-    LicensetypesFeature:
-      properties:
-        active:
-          type: boolean
-        name:
-          type: string
-        route:
-          type: string
-        usage:
-          format: int64
-          type: integer
-        usage_limit:
-          format: int64
-          type: integer
-      type: object
-    LicensetypesGettableActiveLicense:
-      properties:
-        createdAt:
-          format: date-time
-          type: string
-        eventQueue:
-          $ref: '#/components/schemas/LicensetypesLicenseEventQueue'
-        features:
-          items:
-            $ref: '#/components/schemas/LicensetypesFeature'
-          nullable: true
-          type: array
-        freeUntil:
-          format: date-time
-          type: string
-        id:
-          type: string
-        plan:
-          $ref: '#/components/schemas/LicensetypesLicensePlan'
-        platform:
-          type: string
-        state:
-          type: string
-        status:
-          type: string
-        updatedAt:
-          format: date-time
-          type: string
-        validFrom:
-          format: int64
-          type: integer
-        validUntil:
-          format: int64
-          type: integer
-      required:
-      - id
-      - validFrom
-      - validUntil
-      - status
-      - state
-      - platform
-      - freeUntil
-      - createdAt
-      - updatedAt
-      - plan
-      - features
-      - eventQueue
-      type: object
-    LicensetypesGettableLicense:
-      properties:
-        createdAt:
-          format: date-time
-          type: string
-        eventQueue:
-          $ref: '#/components/schemas/LicensetypesLicenseEventQueue'
-        features:
-          items:
-            $ref: '#/components/schemas/LicensetypesFeature'
-          nullable: true
-          type: array
-        freeUntil:
-          format: date-time
-          type: string
-        id:
-          type: string
-        plan:
-          $ref: '#/components/schemas/LicensetypesLicensePlan'
-        platform:
-          type: string
-        state:
-          type: string
-        status:
-          type: string
-        updatedAt:
-          format: date-time
-          type: string
-        validFrom:
-          format: int64
-          type: integer
-        validUntil:
-          format: int64
-          type: integer
-      required:
-      - id
-      - validFrom
-      - validUntil
-      - status
-      - state
-      - platform
-      - freeUntil
-      - createdAt
-      - updatedAt
-      - plan
-      - features
-      - eventQueue
-      type: object
-    LicensetypesGettableLicenseWithKey:
-      properties:
-        createdAt:
-          format: date-time
-          type: string
-        eventQueue:
-          $ref: '#/components/schemas/LicensetypesLicenseEventQueue'
-        features:
-          items:
-            $ref: '#/components/schemas/LicensetypesFeature'
-          nullable: true
-          type: array
-        freeUntil:
-          format: date-time
-          type: string
-        id:
-          type: string
-        key:
-          type: string
-        plan:
-          $ref: '#/components/schemas/LicensetypesLicensePlan'
-        platform:
-          type: string
-        state:
-          type: string
-        status:
-          type: string
-        updatedAt:
-          format: date-time
-          type: string
-        validFrom:
-          format: int64
-          type: integer
-        validUntil:
-          format: int64
-          type: integer
-      required:
-      - id
-      - validFrom
-      - validUntil
-      - status
-      - state
-      - platform
-      - freeUntil
-      - createdAt
-      - updatedAt
-      - plan
-      - features
-      - eventQueue
-      - key
-      type: object
-    LicensetypesLicenseEventQueue:
-      properties:
-        createdAt:
-          format: date-time
-          type: string
-        event:
-          type: string
-        scheduledAt:
-          format: date-time
-          type: string
-        status:
-          type: string
-        updatedAt:
-          format: date-time
-          type: string
-      required:
-      - event
-      - status
-      - scheduledAt
-      - createdAt
-      - updatedAt
-      type: object
-    LicensetypesLicensePlan:
-      properties:
-        createdAt:
-          format: date-time
-          type: string
-        description:
-          type: string
-        id:
-          type: string
-        isActive:
-          type: boolean
-        name:
-          type: string
-        updatedAt:
-          format: date-time
-          type: string
-      required:
-      - id
-      - name
-      - description
-      - isActive
-      - createdAt
-      - updatedAt
-      type: object
-    LicensetypesPostableLicense:
-      properties:
-        key:
-          type: string
-      type: object
     LlmpricingruletypesGettablePricingRules:
       properties:
         items:
@@ -8224,7 +8010,6 @@ components:
       - logs
       - metrics
       - meter
-      - ai_observability
       type: string
     SavedviewtypesUpdatableSavedView:
       properties:
@@ -9015,7 +8800,6 @@ components:
       - span
       - trace
       - resource
-      - scope
       - attribute
       - body
       - ""
@@ -15683,8 +15467,10 @@ paths:
                 $ref: '#/components/schemas/RenderErrorResponse'
           description: Internal Server Error
       security:
-      - api_key: []
-      - tokenizer: []
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
       summary: Get features
       tags:
       - features
@@ -24156,9 +23942,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - deployment-host:list
+        - VIEWER
       - tokenizer:
-        - deployment-host:list
+        - VIEWER
       summary: Get host info from Zeus.
       tags:
       - zeus
@@ -24212,9 +23998,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - deployment-host:update
+        - ADMIN
       - tokenizer:
-        - deployment-host:update
+        - ADMIN
       summary: Put host in Zeus for a deployment.
       tags:
       - zeus
@@ -24413,347 +24199,6 @@ paths:
       summary: Get flamegraph view for a trace
       tags:
       - tracedetail
-  /api/v4/licenses:
-    get:
-      deprecated: false
-      description: This endpoint lists all the licenses of the organization.
-      operationId: ListLicenses
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    items:
-                      $ref: '#/components/schemas/LicensetypesGettableLicense'
-                    type: array
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "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
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - license:list
-      - tokenizer:
-        - license:list
-      summary: List licenses.
-      tags:
-      - licenses
-    post:
-      deprecated: false
-      description: This endpoint validates the license key with the upstream server
-        and activates the license for the organization.
-      operationId: ActivateLicense
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/LicensetypesPostableLicense'
-      responses:
-        "202":
-          description: Accepted
-        "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
-        "409":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Conflict
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - license:create
-      - tokenizer:
-        - license:create
-      summary: Activate a license.
-      tags:
-      - licenses
-  /api/v4/licenses/{id}:
-    delete:
-      deprecated: false
-      description: This endpoint deletes the license by id. Licenses managed by SigNoz
-        Cloud cannot be deleted.
-      operationId: DeleteLicense
-      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:
-        - license:delete
-      - tokenizer:
-        - license:delete
-      summary: Delete a license.
-      tags:
-      - licenses
-    get:
-      deprecated: false
-      description: This endpoint gets the license by id.
-      operationId: GetLicense
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/LicensetypesGettableLicenseWithKey'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "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:
-        - license:read
-      - tokenizer:
-        - license:read
-      summary: Get a license.
-      tags:
-      - licenses
-    put:
-      deprecated: false
-      description: This endpoint refreshes the active license of the organization
-        from the upstream server.
-      operationId: RefreshLicense
-      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:
-        - license:update
-      - tokenizer:
-        - license:update
-      summary: Refresh a license.
-      tags:
-      - licenses
-  /api/v4/licenses/active:
-    get:
-      deprecated: false
-      description: This endpoint gets the active license of the organization.
-      operationId: GetActiveLicense
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/LicensetypesGettableActiveLicense'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "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
-        "501":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Implemented
-      security:
-      - api_key: []
-      - tokenizer: []
-      summary: Get the active license.
-      tags:
-      - licenses
   /api/v4/traces/{traceID}/waterfall:
     post:
       deprecated: false

ee/licensing/httplicensing/api.go

@@ -22,6 +22,89 @@ func NewLicensingAPI(licensing licensing.Licensing) licensing.API {
 	return &licensingAPI{licensing: licensing}
 }
 
+func (api *licensingAPI) Activate(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "orgId is invalid"))
+		return
+	}
+
+	req := new(licensetypes.PostableLicense)
+	err = json.NewDecoder(r.Body).Decode(&req)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	err = api.licensing.Activate(r.Context(), orgID, req.Key)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusAccepted, nil)
+}
+
+func (api *licensingAPI) GetActive(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "orgId is invalid"))
+		return
+	}
+
+	license, err := api.licensing.GetActive(r.Context(), orgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	gettableLicense := licensetypes.NewGettableLicense(license.Data, license.Key)
+	render.Success(rw, http.StatusOK, gettableLicense)
+}
+
+func (api *licensingAPI) Refresh(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "orgId is invalid"))
+		return
+	}
+
+	err = api.licensing.Refresh(r.Context(), orgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusNoContent, nil)
+}
+
 func (api *licensingAPI) Checkout(rw http.ResponseWriter, r *http.Request) {
 	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
 	defer cancel()

ee/licensing/httplicensing/provider.go

@@ -96,12 +96,12 @@ func (provider *provider) Validate(ctx context.Context) error {
 }
 
 func (provider *provider) Activate(ctx context.Context, organizationID valuer.UUID, key string) error {
-	zeusLicense, err := provider.zeus.GetLicense(ctx, key)
+	data, err := provider.zeus.GetLicense(ctx, key)
 	if err != nil {
 		return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "unable to fetch license data with upstream server")
 	}
 
-	license, err := licensetypes.NewLicense(zeusLicense, organizationID)
+	license, err := licensetypes.NewLicense(data, organizationID)
 	if err != nil {
 		return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to create license entity")
 	}
@@ -115,47 +115,6 @@ func (provider *provider) Activate(ctx context.Context, organizationID valuer.UU
 	return nil
 }
 
-func (provider *provider) Get(ctx context.Context, organizationID valuer.UUID, licenseID valuer.UUID) (*licensetypes.License, error) {
-	storableLicense, err := provider.store.Get(ctx, organizationID, licenseID)
-	if err != nil {
-		return nil, err
-	}
-
-	return licensetypes.NewLicenseFromStorableLicense(storableLicense)
-}
-
-func (provider *provider) List(ctx context.Context, organizationID valuer.UUID) ([]*licensetypes.License, error) {
-	storableLicenses, err := provider.store.GetAll(ctx, organizationID)
-	if err != nil {
-		return nil, err
-	}
-
-	licenses := make([]*licensetypes.License, 0, len(storableLicenses))
-	for _, storableLicense := range storableLicenses {
-		license, err := licensetypes.NewLicenseFromStorableLicense(storableLicense)
-		if err != nil {
-			return nil, err
-		}
-
-		licenses = append(licenses, license)
-	}
-
-	return licenses, nil
-}
-
-func (provider *provider) Delete(ctx context.Context, organizationID valuer.UUID, licenseID valuer.UUID) error {
-	license, err := provider.Get(ctx, organizationID, licenseID)
-	if err != nil {
-		return err
-	}
-
-	if err := license.ErrIfCloud(); err != nil {
-		return errors.WithAdditionalf(err, "license %s cannot be deleted", licenseID.StringValue())
-	}
-
-	return provider.store.Delete(ctx, organizationID, licenseID)
-}
-
 func (provider *provider) GetActive(ctx context.Context, organizationID valuer.UUID) (*licensetypes.License, error) {
 	storableLicenses, err := provider.store.GetAll(ctx, organizationID)
 	if err != nil {
@@ -180,7 +139,7 @@ func (provider *provider) Refresh(ctx context.Context, organizationID valuer.UUI
 		return err
 	}
 
-	zeusLicense, err := provider.zeus.GetLicense(ctx, activeLicense.Key)
+	data, err := provider.zeus.GetLicense(ctx, activeLicense.Key)
 	if err != nil {
 		if time.Since(activeLicense.LastValidatedAt) > time.Duration(provider.config.FailureThreshold)*provider.config.PollInterval {
 			activeLicense.UpdateFeatures(licensetypes.BasicPlan)
@@ -195,7 +154,7 @@ func (provider *provider) Refresh(ctx context.Context, organizationID valuer.UUI
 		return err
 	}
 
-	err = activeLicense.Update(zeusLicense)
+	err = activeLicense.Update(data)
 	if err != nil {
 		return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to create license entity from license data")
 	}

ee/licensing/licensingstore/sqllicensingstore/store.go

@@ -64,22 +64,6 @@ func (store *store) GetAll(ctx context.Context, organizationID valuer.UUID) ([]*
 	return storableLicenses, nil
 }
 
-func (store *store) Delete(ctx context.Context, organizationID valuer.UUID, licenseID valuer.UUID) error {
-	_, err := store.
-		sqlstore.
-		BunDB().
-		NewDelete().
-		Model(new(licensetypes.StorableLicense)).
-		Where("org_id = ?", organizationID).
-		Where("id = ?", licenseID).
-		Exec(ctx)
-	if err != nil {
-		return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "unable to delete license with ID: %s", licenseID)
-	}
-
-	return nil
-}
-
 func (store *store) Update(ctx context.Context, organizationID valuer.UUID, storableLicense *licensetypes.StorableLicense) error {
 	_, err := store.
 		sqlstore.

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

@@ -67,7 +67,7 @@ func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	// note: add ee override methods first
 
 	// routes available only in ee version
-	router.HandleFunc("/api/v1/features", am.OpenAccess(ah.getFeatureFlags)).Methods(http.MethodGet)
+	router.HandleFunc("/api/v1/features", am.ViewAccess(ah.getFeatureFlags)).Methods(http.MethodGet)
 
 	// base overrides
 	router.HandleFunc("/api/v1/version", am.OpenAccess(ah.getVersion)).Methods(http.MethodGet)
@@ -76,6 +76,11 @@ func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	router.HandleFunc("/api/v1/billing", am.AdminAccess(ah.getBilling)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/portal", am.AdminAccess(ah.LicensingAPI.Portal)).Methods(http.MethodPost)
 
+	// v3
+	router.HandleFunc("/api/v3/licenses", am.AdminAccess(ah.LicensingAPI.Activate)).Methods(http.MethodPost)
+	router.HandleFunc("/api/v3/licenses", am.AdminAccess(ah.LicensingAPI.Refresh)).Methods(http.MethodPut)
+	router.HandleFunc("/api/v3/licenses/active", am.ViewAccess(ah.LicensingAPI.GetActive)).Methods(http.MethodGet)
+
 	// v4
 	router.HandleFunc("/api/v4/query_range", am.ViewAccess(ah.queryRangeV4)).Methods(http.MethodPost)
 

ee/zeus/httpzeus/provider.go

@@ -51,7 +51,7 @@ func New(ctx context.Context, providerSettings factory.ProviderSettings, config
 	}, nil
 }
 
-func (provider *Provider) GetLicense(ctx context.Context, key string) (*zeustypes.License, error) {
+func (provider *Provider) GetLicense(ctx context.Context, key string) ([]byte, error) {
 	response, err := provider.do(
 		ctx,
 		provider.config.URL.JoinPath("/v2/licenses/me"),
@@ -63,12 +63,7 @@ func (provider *Provider) GetLicense(ctx context.Context, key string) (*zeustype
 		return nil, err
 	}
 
-	license := new(zeustypes.License)
-	if err := json.Unmarshal([]byte(gjson.GetBytes(response, "data").String()), license); err != nil {
-		return nil, errors.Wrapf(err, errors.TypeInternal, zeus.ErrCodeResponseMalformed, "failed to unmarshal license data")
-	}
-
-	return license, nil
+	return []byte(gjson.GetBytes(response, "data").String()), nil
 }
 
 func (provider *Provider) GetCheckoutURL(ctx context.Context, key string, body []byte) ([]byte, error) {

frontend/src/AppRoutes/__tests__/Private.test.tsx

@@ -103,30 +103,30 @@ function createMockLicense(
 	overrides: Partial<LicenseResModel> = {},
 ): LicenseResModel {
 	return {
-		id: 'test-license-id',
-		eventQueue: {
-			createdAt: '0',
+		key: 'test-key',
+		event_queue: {
+			created_at: '0',
 			event: LicenseEvent.NO_EVENT,
-			scheduledAt: '0',
+			scheduled_at: '0',
 			status: '',
-			updatedAt: '0',
+			updated_at: '0',
 		},
 		state: LicenseState.ACTIVATED,
 		status: LicenseStatus.VALID,
 		platform: LicensePlatform.CLOUD,
-		createdAt: '0',
+		created_at: '0',
 		plan: {
-			id: '0',
-			createdAt: '0',
+			created_at: '0',
 			description: '',
-			isActive: true,
+			is_active: true,
 			name: '',
-			updatedAt: '0',
+			updated_at: '0',
 		},
-		freeUntil: '0',
-		updatedAt: '0',
-		validFrom: 0,
-		validUntil: 0,
+		plan_id: '0',
+		free_until: '0',
+		updated_at: '0',
+		valid_from: 0,
+		valid_until: 0,
 		...overrides,
 	};
 }

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

@@ -1,538 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
- * SigNoz
- */
-import { useMutation, useQuery } from 'react-query';
-import type {
-	InvalidateOptions,
-	MutationFunction,
-	QueryClient,
-	QueryFunction,
-	QueryKey,
-	UseMutationOptions,
-	UseMutationResult,
-	UseQueryOptions,
-	UseQueryResult,
-} from 'react-query';
-
-import type {
-	DeleteLicensePathParameters,
-	GetActiveLicense200,
-	GetLicense200,
-	GetLicensePathParameters,
-	LicensetypesPostableLicenseDTO,
-	ListLicenses200,
-	RefreshLicensePathParameters,
-	RenderErrorResponseDTO,
-} from '../sigNoz.schemas';
-
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
-
-/**
- * This endpoint lists all the licenses of the organization.
- * @summary List licenses.
- */
-export const listLicenses = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<ListLicenses200>({
-		url: `/api/v4/licenses`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getListLicensesQueryKey = () => {
-	return [`/api/v4/licenses`] as const;
-};
-
-export const getListLicensesQueryOptions = <
-	TData = Awaited<ReturnType<typeof listLicenses>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof listLicenses>>,
-		TError,
-		TData
-	>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getListLicensesQueryKey();
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof listLicenses>>> = ({
-		signal,
-	}) => listLicenses(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listLicenses>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListLicensesQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listLicenses>>
->;
-export type ListLicensesQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List licenses.
- */
-
-export function useListLicenses<
-	TData = Awaited<ReturnType<typeof listLicenses>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof listLicenses>>,
-		TError,
-		TData
-	>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListLicensesQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary List licenses.
- */
-export const invalidateListLicenses = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListLicensesQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint validates the license key with the upstream server and activates the license for the organization.
- * @summary Activate a license.
- */
-export const activateLicense = (
-	licensetypesPostableLicenseDTO?: BodyType<LicensetypesPostableLicenseDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v4/licenses`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: licensetypesPostableLicenseDTO,
-		signal,
-	});
-};
-
-export const getActivateLicenseMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof activateLicense>>,
-		TError,
-		{ data?: BodyType<LicensetypesPostableLicenseDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof activateLicense>>,
-	TError,
-	{ data?: BodyType<LicensetypesPostableLicenseDTO> },
-	TContext
-> => {
-	const mutationKey = ['activateLicense'];
-	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 activateLicense>>,
-		{ data?: BodyType<LicensetypesPostableLicenseDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return activateLicense(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type ActivateLicenseMutationResult = NonNullable<
-	Awaited<ReturnType<typeof activateLicense>>
->;
-export type ActivateLicenseMutationBody =
-	| BodyType<LicensetypesPostableLicenseDTO>
-	| undefined;
-export type ActivateLicenseMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Activate a license.
- */
-export const useActivateLicense = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof activateLicense>>,
-		TError,
-		{ data?: BodyType<LicensetypesPostableLicenseDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof activateLicense>>,
-	TError,
-	{ data?: BodyType<LicensetypesPostableLicenseDTO> },
-	TContext
-> => {
-	return useMutation(getActivateLicenseMutationOptions(options));
-};
-/**
- * This endpoint deletes the license by id. Licenses managed by SigNoz Cloud cannot be deleted.
- * @summary Delete a license.
- */
-export const deleteLicense = (
-	{ id }: DeleteLicensePathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v4/licenses/${id}`,
-		method: 'DELETE',
-		signal,
-	});
-};
-
-export const getDeleteLicenseMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteLicense>>,
-		TError,
-		{ pathParams: DeleteLicensePathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteLicense>>,
-	TError,
-	{ pathParams: DeleteLicensePathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteLicense'];
-	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 deleteLicense>>,
-		{ pathParams: DeleteLicensePathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteLicense(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteLicenseMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteLicense>>
->;
-
-export type DeleteLicenseMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete a license.
- */
-export const useDeleteLicense = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteLicense>>,
-		TError,
-		{ pathParams: DeleteLicensePathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteLicense>>,
-	TError,
-	{ pathParams: DeleteLicensePathParameters },
-	TContext
-> => {
-	return useMutation(getDeleteLicenseMutationOptions(options));
-};
-/**
- * This endpoint gets the license by id.
- * @summary Get a license.
- */
-export const getLicense = (
-	{ id }: GetLicensePathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetLicense200>({
-		url: `/api/v4/licenses/${id}`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetLicenseQueryKey = ({ id }: GetLicensePathParameters) => {
-	return [`/api/v4/licenses/${id}`] as const;
-};
-
-export const getGetLicenseQueryOptions = <
-	TData = Awaited<ReturnType<typeof getLicense>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ id }: GetLicensePathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getLicense>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getGetLicenseQueryKey({ id });
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof getLicense>>> = ({
-		signal,
-	}) => getLicense({ id }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<Awaited<ReturnType<typeof getLicense>>, TError, TData> & {
-		queryKey: QueryKey;
-	};
-};
-
-export type GetLicenseQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getLicense>>
->;
-export type GetLicenseQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get a license.
- */
-
-export function useGetLicense<
-	TData = Awaited<ReturnType<typeof getLicense>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ id }: GetLicensePathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getLicense>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetLicenseQueryOptions({ id }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Get a license.
- */
-export const invalidateGetLicense = async (
-	queryClient: QueryClient,
-	{ id }: GetLicensePathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetLicenseQueryKey({ id }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint refreshes the active license of the organization from the upstream server.
- * @summary Refresh a license.
- */
-export const refreshLicense = (
-	{ id }: RefreshLicensePathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v4/licenses/${id}`,
-		method: 'PUT',
-		signal,
-	});
-};
-
-export const getRefreshLicenseMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof refreshLicense>>,
-		TError,
-		{ pathParams: RefreshLicensePathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof refreshLicense>>,
-	TError,
-	{ pathParams: RefreshLicensePathParameters },
-	TContext
-> => {
-	const mutationKey = ['refreshLicense'];
-	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 refreshLicense>>,
-		{ pathParams: RefreshLicensePathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return refreshLicense(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type RefreshLicenseMutationResult = NonNullable<
-	Awaited<ReturnType<typeof refreshLicense>>
->;
-
-export type RefreshLicenseMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Refresh a license.
- */
-export const useRefreshLicense = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof refreshLicense>>,
-		TError,
-		{ pathParams: RefreshLicensePathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof refreshLicense>>,
-	TError,
-	{ pathParams: RefreshLicensePathParameters },
-	TContext
-> => {
-	return useMutation(getRefreshLicenseMutationOptions(options));
-};
-/**
- * This endpoint gets the active license of the organization.
- * @summary Get the active license.
- */
-export const getActiveLicense = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<GetActiveLicense200>({
-		url: `/api/v4/licenses/active`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetActiveLicenseQueryKey = () => {
-	return [`/api/v4/licenses/active`] as const;
-};
-
-export const getGetActiveLicenseQueryOptions = <
-	TData = Awaited<ReturnType<typeof getActiveLicense>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof getActiveLicense>>,
-		TError,
-		TData
-	>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getGetActiveLicenseQueryKey();
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof getActiveLicense>>> = ({
-		signal,
-	}) => getActiveLicense(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof getActiveLicense>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetActiveLicenseQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getActiveLicense>>
->;
-export type GetActiveLicenseQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get the active license.
- */
-
-export function useGetActiveLicense<
-	TData = Awaited<ReturnType<typeof getActiveLicense>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof getActiveLicense>>,
-		TError,
-		TData
-	>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetActiveLicenseQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Get the active license.
- */
-export const invalidateGetActiveLicense = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetActiveLicenseQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};

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

@@ -2175,7 +2175,6 @@ export enum CoretypesKindDTO {
 	'factor-api-key' = 'factor-api-key',
 	license = 'license',
 	subscription = 'subscription',
-	'deployment-host' = 'deployment-host',
 	logs = 'logs',
 	traces = 'traces',
 	metrics = 'metrics',
@@ -3493,7 +3492,6 @@ export enum TelemetrytypesFieldContextDTO {
 	span = 'span',
 	trace = 'trace',
 	resource = 'resource',
-	scope = 'scope',
 	attribute = 'attribute',
 	body = 'body',
 	'' = '',
@@ -7173,247 +7171,6 @@ export interface InframonitoringtypesVolumesDTO {
 	warning?: Querybuildertypesv5QueryWarnDataDTO;
 }
 
-export interface LicensetypesFeatureDTO {
-	/**
-	 * @type boolean
-	 */
-	active?: boolean;
-	/**
-	 * @type string
-	 */
-	name?: string;
-	/**
-	 * @type string
-	 */
-	route?: string;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	usage?: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	usage_limit?: number;
-}
-
-export interface LicensetypesLicenseEventQueueDTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt: string;
-	/**
-	 * @type string
-	 */
-	event: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	scheduledAt: string;
-	/**
-	 * @type string
-	 */
-	status: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt: string;
-}
-
-export interface LicensetypesLicensePlanDTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt: string;
-	/**
-	 * @type string
-	 */
-	description: string;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type boolean
-	 */
-	isActive: boolean;
-	/**
-	 * @type string
-	 */
-	name: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt: string;
-}
-
-export interface LicensetypesGettableActiveLicenseDTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt: string;
-	eventQueue: LicensetypesLicenseEventQueueDTO;
-	/**
-	 * @type array,null
-	 */
-	features: LicensetypesFeatureDTO[] | null;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	freeUntil: string;
-	/**
-	 * @type string
-	 */
-	id: string;
-	plan: LicensetypesLicensePlanDTO;
-	/**
-	 * @type string
-	 */
-	platform: string;
-	/**
-	 * @type string
-	 */
-	state: string;
-	/**
-	 * @type string
-	 */
-	status: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt: string;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	validFrom: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	validUntil: number;
-}
-
-export interface LicensetypesGettableLicenseDTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt: string;
-	eventQueue: LicensetypesLicenseEventQueueDTO;
-	/**
-	 * @type array,null
-	 */
-	features: LicensetypesFeatureDTO[] | null;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	freeUntil: string;
-	/**
-	 * @type string
-	 */
-	id: string;
-	plan: LicensetypesLicensePlanDTO;
-	/**
-	 * @type string
-	 */
-	platform: string;
-	/**
-	 * @type string
-	 */
-	state: string;
-	/**
-	 * @type string
-	 */
-	status: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt: string;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	validFrom: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	validUntil: number;
-}
-
-export interface LicensetypesGettableLicenseWithKeyDTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt: string;
-	eventQueue: LicensetypesLicenseEventQueueDTO;
-	/**
-	 * @type array,null
-	 */
-	features: LicensetypesFeatureDTO[] | null;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	freeUntil: string;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type string
-	 */
-	key: string;
-	plan: LicensetypesLicensePlanDTO;
-	/**
-	 * @type string
-	 */
-	platform: string;
-	/**
-	 * @type string
-	 */
-	state: string;
-	/**
-	 * @type string
-	 */
-	status: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt: string;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	validFrom: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	validUntil: number;
-}
-
-export interface LicensetypesPostableLicenseDTO {
-	/**
-	 * @type string
-	 */
-	key?: string;
-}
-
 /**
  * @nullable
  */
@@ -9264,7 +9021,6 @@ export enum SavedviewtypesSourceDTO {
 	logs = 'logs',
 	metrics = 'metrics',
 	meter = 'meter',
-	ai_observability = 'ai_observability',
 }
 export interface SavedviewtypesSavedViewSpecDTO {
 	display?: SavedviewtypesDisplayDTO;
@@ -12670,42 +12426,6 @@ export type GetFlamegraph200 = {
 	status: string;
 };
 
-export type ListLicenses200 = {
-	/**
-	 * @type array
-	 */
-	data: LicensetypesGettableLicenseDTO[];
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type DeleteLicensePathParameters = {
-	id: string;
-};
-export type GetLicensePathParameters = {
-	id: string;
-};
-export type GetLicense200 = {
-	data: LicensetypesGettableLicenseWithKeyDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type RefreshLicensePathParameters = {
-	id: string;
-};
-export type GetActiveLicense200 = {
-	data: LicensetypesGettableActiveLicenseDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetWaterfallV4PathParameters = {
 	traceID: string;
 };

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

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

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

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

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

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

frontend/src/components/ExplorerCard/ExplorerCard.tsx

@@ -7,8 +7,9 @@ import axios from 'axios';
 import TextToolTip from 'components/TextToolTip';
 import { SOMETHING_WENT_WRONG } from 'constants/api';
 import { LOCALSTORAGE } from 'constants/localStorage';
+import { QueryParams } from 'constants/query';
 import { useOptionsMenu } from 'container/OptionsMenu';
-import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
+import { useGetSearchQueryParam } from 'hooks/queryBuilder/useGetSearchQueryParam';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useDeleteView } from 'hooks/saveViews/useDeleteView';
 import { useGetAllViews } from 'hooks/saveViews/useGetAllViews';
@@ -68,7 +69,9 @@ function ExplorerCard({
 		setIsOpen(newOpen);
 	};
 
-	const { viewName, viewKey } = useGetSavedViewParams();
+	const viewName = useGetSearchQueryParam(QueryParams.viewName) || '';
+
+	const viewKey = useGetSearchQueryParam(QueryParams.viewKey) || '';
 
 	const { options } = useOptionsMenu({
 		storageKey:

frontend/src/components/ExplorerCard/constants.ts

@@ -1,3 +1,5 @@
+import { QueryParams } from 'constants/query';
+
 export const ExploreHeaderToolTip = {
 	url: 'https://signoz.io/docs/querying/overview/?utm_source=product&utm_medium=new-query-builder',
 	text: 'More details on how to use query builder',
@@ -7,3 +9,5 @@ export const SaveButtonText = {
 	SAVE_AS_NEW_VIEW: 'Save as new view',
 	SAVE_VIEW: 'Save view',
 };
+
+export type QuerySearchParamNames = QueryParams.viewName | QueryParams.viewKey;

frontend/src/components/QueryBuilderV2/QueryBuilderV2.tsx

@@ -241,29 +241,28 @@ export const QueryBuilderV2 = memo(function QueryBuilderV2({
 						))
 					)}
 
-					{!showOnlyWhereClause &&
-						currentQuery.builder.queryFormulas?.length > 0 && (
-							<div className="qb-formulas-container">
-								{currentQuery.builder.queryFormulas.map((formula, index) => {
-									const query =
-										currentQuery.builder.queryData[index] ||
-										currentQuery.builder.queryData[0];
+					{!showOnlyWhereClause && currentQuery.builder.queryFormulas.length > 0 && (
+						<div className="qb-formulas-container">
+							{currentQuery.builder.queryFormulas.map((formula, index) => {
+								const query =
+									currentQuery.builder.queryData[index] ||
+									currentQuery.builder.queryData[0];
 
-									return (
-										<div key={formula.queryName} className="qb-formula">
-											<Formula
-												filterConfigs={filterConfigs}
-												query={query}
-												formula={formula}
-												index={index}
-												isAdditionalFilterEnable={false}
-												isQBV2
-											/>
-										</div>
-									);
-								})}
-							</div>
-						)}
+								return (
+									<div key={formula.queryName} className="qb-formula">
+										<Formula
+											filterConfigs={filterConfigs}
+											query={query}
+											formula={formula}
+											index={index}
+											isAdditionalFilterEnable={false}
+											isQBV2
+										/>
+									</div>
+								);
+							})}
+						</div>
+					)}
 
 					{shouldShowFooter && (
 						<QueryFooter
@@ -291,7 +290,7 @@ export const QueryBuilderV2 = memo(function QueryBuilderV2({
 							</div>
 						))}
 
-						{currentQuery.builder.queryFormulas?.map((formula) => (
+						{currentQuery.builder.queryFormulas.map((formula) => (
 							<div key={formula.queryName} className="formula-name">
 								{formula.queryName}
 							</div>

frontend/src/components/QueryBuilderV2/QueryV2/__tests__/QueryV2.test.tsx

@@ -212,32 +212,6 @@ describe('QueryBuilderV2 + QueryV2 - base render', () => {
 		expect(handleRunQueryMock).toHaveBeenCalled();
 	});
 
-	it('does not crash when builder.queryFormulas/queryTraceOperator are missing (partial/legacy query)', () => {
-		const currentQueryBase = baseQBContext.currentQuery as Query;
-
-		mockedUseQueryBuilder.mockReturnValue({
-			...baseQBContext,
-			currentQuery: {
-				...currentQueryBase,
-				builder: {
-					queryData: currentQueryBase.builder.queryData,
-					queryFormulas: undefined as unknown as [],
-					queryTraceOperator: undefined as unknown as [],
-				},
-			},
-		});
-
-		expect(() =>
-			render(<QueryBuilderV2 panelType={PANEL_TYPES.TABLE} version="v4" />),
-		).not.toThrow();
-
-		// query list still renders from queryData, formulas block is skipped
-		expect(document.querySelector('.query-names-section')).toBeInTheDocument();
-		expect(
-			document.querySelector('.qb-formulas-container'),
-		).not.toBeInTheDocument();
-	});
-
 	it('fx button is disabled when functions already exist', () => {
 		const currentQueryBase = baseQBContext.currentQuery as Query;
 		const supersetQueryBase = baseQBContext.supersetQuery as Query;

frontend/src/components/RefreshPaymentStatus/RefreshPaymentStatus.tsx

@@ -1,6 +1,6 @@
 import { useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { refreshLicense } from 'api/generated/services/licenses';
+import refreshPaymentStatus from 'api/v3/licenses/put';
 import { Button } from '@signozhq/ui/button';
 import { TooltipSimple } from '@signozhq/ui/tooltip';
 import { RefreshCcw } from '@signozhq/icons';
@@ -14,21 +14,17 @@ function RefreshPaymentStatus({
 	className?: string;
 }): JSX.Element {
 	const { t } = useTranslation(['failedPayment']);
-	const { activeLicense, activeLicenseRefetch } = useAppContext();
+	const { activeLicenseRefetch } = useAppContext();
 
 	const [isLoading, setIsLoading] = useState(false);
 
 	const handleRefreshPaymentStatus = async (): Promise<void> => {
-		if (!activeLicense) {
-			return;
-		}
-
 		setIsLoading(true);
 
 		try {
-			await refreshLicense({ id: activeLicense.id });
+			await refreshPaymentStatus();
 
-			activeLicenseRefetch();
+			await Promise.all([activeLicenseRefetch()]);
 		} catch (e) {
 			console.error(e);
 		}

frontend/src/components/ServiceAccountDrawer/__tests__/ServiceAccountDrawer.authz.test.tsx

@@ -4,7 +4,7 @@ import {
 } from 'mocks-server/__mockdata__/roles';
 import { rest, server } from 'mocks-server/server';
 import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
-import { render, screen, waitFor } from 'tests/test-utils';
+import { fireEvent, render, screen, waitFor } from 'tests/test-utils';
 import {
 	setupAuthzAdmin,
 	setupAuthzDeny,
@@ -110,7 +110,10 @@ describe('ServiceAccountDrawer — permissions', () => {
 	it('shows PermissionDeniedCallout in Keys tab when list-keys permission is denied', async () => {
 		server.use(setupAuthzDeny(APIKeyListPermission));
 
-		renderDrawer({ account: 'sa-1', tab: 'keys' });
+		renderDrawer();
+		await screen.findByDisplayValue('CI Bot');
+
+		fireEvent.click(screen.getByRole('radio', { name: /keys/i }));
 
 		await waitFor(() => {
 			expect(screen.getByText(/list:factor-api-key/)).toBeInTheDocument();

frontend/src/constants/reactQueryKeys.ts

@@ -28,6 +28,7 @@ export const REACT_QUERY_KEY = {
 	DUPLICATE_ALERT_RULE: 'DUPLICATE_ALERT_RULE',
 	GET_HOST_LIST: 'GET_HOST_LIST',
 	UPDATE_ALERT_RULE: 'UPDATE_ALERT_RULE',
+	GET_ACTIVE_LICENSE_V3: 'GET_ACTIVE_LICENSE_V3',
 	GET_TRACE_V2_WATERFALL: 'GET_TRACE_V2_WATERFALL',
 	GET_TRACE_V4_WATERFALL: 'GET_TRACE_V4_WATERFALL',
 	GET_TRACE_AGGREGATIONS: 'GET_TRACE_AGGREGATIONS',

frontend/src/container/AlertHistory/Timeline/Table/utils.ts

@@ -10,7 +10,6 @@ const fieldContextToSuggestionMap: Record<
 	[TelemetrytypesFieldContextDTO.attribute]: 'attribute',
 	// no maps for the following values on suggestion context
 	[TelemetrytypesFieldContextDTO.trace]: undefined,
-	[TelemetrytypesFieldContextDTO.scope]: undefined,
 	[TelemetrytypesFieldContextDTO.body]: undefined,
 	[TelemetrytypesFieldContextDTO.metric]: undefined,
 	[TelemetrytypesFieldContextDTO.log]: undefined,

frontend/src/container/AppLayout/index.tsx

@@ -453,7 +453,7 @@ function AppLayout(props: AppLayoutProps): JSX.Element {
 		if (
 			!isFetchingActiveLicense &&
 			!isNull(activeLicense) &&
-			activeLicense?.eventQueue?.event === LicenseEvent.DEFAULT
+			activeLicense?.event_queue?.event === LicenseEvent.DEFAULT
 		) {
 			setShowPaymentFailedWarning(true);
 		}
@@ -820,7 +820,7 @@ function AppLayout(props: AppLayoutProps): JSX.Element {
 								Your bill payment has failed. Your workspace will get suspended on{' '}
 								<span>
 									{getFormattedDateWithMinutes(
-										dayjs(activeLicense?.eventQueue?.scheduledAt).unix() || Date.now(),
+										dayjs(activeLicense?.event_queue?.scheduled_at).unix() || Date.now(),
 									)}
 									.
 								</span>

frontend/src/container/BillingContainer/BillingContainer.test.tsx

@@ -15,11 +15,6 @@ import { getFormattedDate } from 'utils/timeUtils';
 
 import BillingContainer from './BillingContainer';
 
-jest.mock('hooks/useActiveLicenseKey/useActiveLicenseKey', () => ({
-	__esModule: true,
-	default: jest.fn(() => ({ licenseKey: 'test-key', isLoading: false })),
-}));
-
 window.ResizeObserver =
 	window.ResizeObserver ||
 	jest.fn().mockImplementation(() => ({

frontend/src/container/BillingContainer/BillingContainer.tsx

@@ -30,7 +30,6 @@ import useAxiosError from 'hooks/useAxiosError';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { useNotifications } from 'hooks/useNotifications';
 import { isEmpty, pick } from 'lodash-es';
-import useActiveLicenseKey from 'hooks/useActiveLicenseKey/useActiveLicenseKey';
 import { useAppContext } from 'providers/App/App';
 import { ErrorResponse, SuccessResponse, SuccessResponseV2 } from 'types/api';
 import { CheckoutSuccessPayloadProps } from 'types/api/billing/checkout';
@@ -146,7 +145,6 @@ export default function BillingContainer(): JSX.Element {
 		activeLicense,
 		activeLicenseFetchError,
 	} = useAppContext();
-	const { licenseKey } = useActiveLicenseKey();
 	const { notifications } = useNotifications();
 
 	const handleError = useAxiosError();
@@ -209,9 +207,9 @@ export default function BillingContainer(): JSX.Element {
 		isFetching: isFetchingBillingData,
 		data: billingData,
 	} = useQuery([REACT_QUERY_KEY.GET_BILLING_USAGE, user?.id], {
-		queryFn: () => getUsage(licenseKey || ''),
+		queryFn: () => getUsage(activeLicense?.key || ''),
 		onError: handleError,
-		enabled: !!licenseKey,
+		enabled: activeLicense !== null,
 		onSuccess: processUsageData,
 	});
 

frontend/src/container/ExplorerOptions/ExplorerOptions.tsx

@@ -54,7 +54,7 @@ import {
 } from 'container/OptionsMenu/constants';
 import { OptionsQuery } from 'container/OptionsMenu/types';
 import { ExportDashboard } from 'hooks/dashboard/useExportDashboards';
-import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
+import { useGetSearchQueryParam } from 'hooks/queryBuilder/useGetSearchQueryParam';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useGetAllViews } from 'hooks/saveViews/useGetAllViews';
 import { useSaveView } from 'hooks/saveViews/useSaveView';
@@ -287,7 +287,8 @@ function ExplorerOptions({
 
 	const compositeQuery = mapCompositeQueryFromQuery(currentQuery, panelType);
 
-	const { viewName, viewKey } = useGetSavedViewParams();
+	const viewName = useGetSearchQueryParam(QueryParams.viewName) || '';
+	const viewKey = useGetSearchQueryParam(QueryParams.viewKey) || '';
 
 	const extraData = viewsData?.data?.data?.find(
 		(view) => view.id === viewKey,

frontend/src/container/FormAlertRules/utils.ts

@@ -53,24 +53,17 @@ export const getUpdatedStepInterval = (evalWindow?: string): number => {
 };
 
 export const getSelectedQueryOptions = (
-	queries:
-		| Array<
-				| IBuilderQuery
-				| IBuilderTraceOperator
-				| IBuilderFormula
-				| IClickHouseQuery
-				| IPromQLQuery
-		  >
-		| undefined
-		| null,
-): SelectProps['options'] => {
-	if (!queries) {
-		return [];
-	}
-	return queries
+	queries: Array<
+		| IBuilderQuery
+		| IBuilderTraceOperator
+		| IBuilderFormula
+		| IClickHouseQuery
+		| IPromQLQuery
+	>,
+): SelectProps['options'] =>
+	queries
 		.filter((query) => !query.disabled)
 		.map((query) => ({
 			label: 'queryName' in query ? query.queryName : query.name,
 			value: 'queryName' in query ? query.queryName : query.name,
 		}));
-};

frontend/src/container/GeneralSettings/GeneralSettings.tsx

@@ -16,7 +16,6 @@ import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { useNotifications } from 'hooks/useNotifications';
 import { StatusCodes } from 'http-status-codes';
 import find from 'lodash-es/find';
-import useActiveLicenseKey from 'hooks/useActiveLicenseKey/useActiveLicenseKey';
 import { useAppContext } from 'providers/App/App';
 import {
 	ErrorResponse,
@@ -79,8 +78,7 @@ function GeneralSettings({
 	const [logsCurrentTTLValues, setLogsCurrentTTLValues] =
 		useState(logsTtlValuesPayload);
 
-	const { user } = useAppContext();
-	const { licenseKey } = useActiveLicenseKey();
+	const { user, activeLicense } = useAppContext();
 
 	const [setRetentionPermission] = useComponentPermission(
 		['set_retention_period'],
@@ -675,13 +673,13 @@ function GeneralSettings({
 				</span>
 			</div>
 
-			{(showCustomDomainSettings || licenseKey) && (
+			{(showCustomDomainSettings || activeLicense?.key) && (
 				<div className="custom-domain-card">
 					{showCustomDomainSettings && <CustomDomainSettings />}
-					{showCustomDomainSettings && licenseKey && (
+					{showCustomDomainSettings && activeLicense?.key && (
 						<div className="custom-domain-card-divider" />
 					)}
-					{licenseKey && (
+					{activeLicense?.key && (
 						<>
 							<LicenseKeyRow />
 							<LicenseRowDismissibleCallout />

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

@@ -2,16 +2,16 @@ import { useCopyToClipboard } from 'react-use';
 import { Copy, KeyRound } from '@signozhq/icons';
 import { Button } from '@signozhq/ui/button';
 import { toast } from '@signozhq/ui/sonner';
-import useActiveLicenseKey from 'hooks/useActiveLicenseKey/useActiveLicenseKey';
+import { useAppContext } from 'providers/App/App';
 import { getMaskedKey } from 'utils/maskedKey';
 
 import './LicenseKeyRow.styles.scss';
 
 function LicenseKeyRow(): JSX.Element | null {
-	const { licenseKey } = useActiveLicenseKey();
+	const { activeLicense } = useAppContext();
 	const [, copyToClipboard] = useCopyToClipboard();
 
-	if (!licenseKey) {
+	if (!activeLicense?.key) {
 		return null;
 	}
 
@@ -27,14 +27,16 @@ function LicenseKeyRow(): JSX.Element | null {
 				<span className="license-key-row__label">SigNoz License Key</span>
 			</span>
 			<span className="license-key-row__value">
-				<code className="license-key-row__code">{getMaskedKey(licenseKey)}</code>
+				<code className="license-key-row__code">
+					{getMaskedKey(activeLicense.key)}
+				</code>
 				<Button
 					type="button"
 					size="sm"
 					aria-label="Copy license key"
 					data-testid="license-key-row-copy-btn"
 					className="license-key-row__copy-btn"
-					onClick={(): void => handleCopyLicenseKey(licenseKey)}
+					onClick={(): void => handleCopyLicenseKey(activeLicense.key)}
 				>
 					<Copy size={12} />
 				</Button>

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

@@ -1,13 +1,7 @@
 import { render, screen, userEvent, waitFor } from 'tests/test-utils';
-import useActiveLicenseKey from 'hooks/useActiveLicenseKey/useActiveLicenseKey';
 
 import LicenseKeyRow from '../LicenseKeyRow';
 
-jest.mock('hooks/useActiveLicenseKey/useActiveLicenseKey');
-const mockUseActiveLicenseKey = useActiveLicenseKey as jest.MockedFunction<
-	typeof useActiveLicenseKey
->;
-
 const mockCopyToClipboard = jest.fn();
 
 jest.mock('react-use', () => ({
@@ -29,22 +23,20 @@ describe('LicenseKeyRow', () => {
 		jest.clearAllMocks();
 	});
 
-	it('renders nothing when the license key is absent', () => {
-		mockUseActiveLicenseKey.mockReturnValue({
-			licenseKey: undefined,
-			isLoading: false,
+	it('renders nothing when activeLicense key is absent', () => {
+		const { container } = render(<LicenseKeyRow />, undefined, {
+			appContextOverrides: { activeLicense: null },
 		});
-		const { container } = render(<LicenseKeyRow />);
 
 		expect(container).toBeEmptyDOMElement();
 	});
 
-	it('renders label and masked key when the license key exists', () => {
-		mockUseActiveLicenseKey.mockReturnValue({
-			licenseKey: 'abcdefghij',
-			isLoading: false,
+	it('renders label and masked key when activeLicense key exists', () => {
+		render(<LicenseKeyRow />, undefined, {
+			appContextOverrides: {
+				activeLicense: { key: 'abcdefghij' } as any,
+			},
 		});
-		render(<LicenseKeyRow />);
 
 		expect(screen.getByText('SigNoz License Key')).toBeInTheDocument();
 		expect(screen.getByText('ab·······ij')).toBeInTheDocument();
@@ -53,10 +45,6 @@ describe('LicenseKeyRow', () => {
 	it('calls copyToClipboard and shows success toast when clipboard is available', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 
-		mockUseActiveLicenseKey.mockReturnValue({
-			licenseKey: 'test-key',
-			isLoading: false,
-		});
 		render(<LicenseKeyRow />);
 
 		await user.click(screen.getByRole('button', { name: /copy license key/i }));

frontend/src/container/LLMObservability/Explorer/Explorer.module.scss

@@ -0,0 +1,11 @@
+.explorer {
+	display: flex;
+	flex-direction: column;
+	gap: var(--spacing-4);
+	padding: var(--spacing-2) var(--spacing-0);
+}
+
+.placeholder {
+	color: var(--l2-foreground);
+	font-size: var(--periscope-font-size-base);
+}

frontend/src/container/LLMObservability/Explorer/Explorer.styles.scss

@@ -1,106 +0,0 @@
-.trace-explorer-header {
-	.trace-explorer-run-query {
-		display: flex;
-		flex-direction: row-reverse;
-		align-items: center;
-		margin: 8px 16px;
-		gap: 8px;
-	}
-
-	.filter-outlined-btn {
-		border-radius: 0px 2px 2px 0px;
-		border-top: 1px solid var(--l1-border);
-		border-right: 1px solid var(--l1-border);
-		border-bottom: 1px solid var(--l1-border);
-		background: var(--l2-background);
-		box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, 0.1);
-	}
-}
-
-.trace-explorer-header.single-child {
-	justify-content: flex-end;
-}
-
-.traces-explorer-views {
-	padding: 8px;
-	padding-bottom: 60px;
-	margin-bottom: 24px;
-
-	.ant-tabs-tabpane {
-		padding: 0 8px;
-	}
-}
-
-.qb-search-view-container {
-	padding: 8px;
-
-	display: flex;
-	flex-direction: row;
-	align-items: center;
-	gap: 8px;
-
-	.ant-select-selector {
-		border-radius: 2px;
-		border: 1px solid var(--l1-border) !important;
-		background: var(--l2-background) !important;
-		height: 34px !important;
-		box-sizing: border-box !important;
-	}
-}
-
-.trace-explorer-list-view {
-	flex: 1;
-}
-
-.trace-explorer-traces-view {
-	flex: 1;
-}
-
-.trace-explorer-table-view {
-	flex: 1;
-}
-
-.trace-explorer-time-series-view {
-	flex: 1;
-}
-
-.trace-explorer-page {
-	display: flex;
-
-	// Meant to fix the query builder colors
-	--input-background: var(--l2-background);
-	--input-hover-background: var(--l2-background);
-	--input-focus-background: var(--l2-background);
-	--input-border-color: var(--l2-border);
-	--input-hover-border-color: var(--internal-ant-border-color-hover);
-	--input-focus-border-color: var(--internal-ant-border-color-hover);
-
-	.filter {
-		width: 260px;
-		height: 100%;
-		min-height: 100vh;
-
-		border-right: 0px;
-		border: 1px solid var(--l1-border);
-		background-color: var(--l1-background);
-
-		> .ant-card-body {
-			padding: 0;
-			width: 258px;
-		}
-	}
-
-	.trace-explorer {
-		width: 100%;
-		background: var(--l1-background);
-
-		> .ant-card-body {
-			padding: 0;
-		}
-
-		border-color: var(--l1-border);
-	}
-	.trace-explorer.filters-expanded {
-		width: calc(100% - 260px);
-	}
-}

frontend/src/container/LLMObservability/Explorer/Explorer.tsx

@@ -1,373 +1,13 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { useQueryClient } from 'react-query';
-import { useSearchParams } from 'react-router-dom-v5-compat';
-import * as Sentry from '@sentry/react';
-import { Card } from 'antd';
-import logEvent from 'api/common/logEvent';
-import cx from 'classnames';
-import ExplorerCard from 'components/ExplorerCard/ExplorerCard';
-import QueryCancelledPlaceholder from 'components/QueryCancelledPlaceholder';
-import QuickFilters from 'components/QuickFilters/QuickFilters';
-import { QuickFiltersSource, SignalType } from 'components/QuickFilters/types';
-import WarningPopover from 'components/WarningPopover/WarningPopover';
-import { AVAILABLE_EXPORT_PANEL_TYPES } from 'constants/panelTypes';
-import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
-import { usePageActions } from 'container/AIAssistant/pageActions/usePageActions';
-import ExplorerOptionWrapper from 'container/ExplorerOptions/ExplorerOptionWrapper';
-import { useOptionsMenu } from 'container/OptionsMenu';
-import LeftToolbarActions from 'container/QueryBuilder/components/ToolbarActions/LeftToolbarActions';
-import RightToolbarActions from 'container/QueryBuilder/components/ToolbarActions/RightToolbarActions';
-import Toolbar from 'container/Toolbar/Toolbar';
-import {
-	getExportQueryData,
-	getQueryByPanelType,
-} from 'container/TracesExplorer/explorerUtils';
-import { ExportDashboard } from 'hooks/dashboard/useExportDashboards';
-import { useGetExportToDashboardLink } from 'hooks/dashboard/useGetExportToDashboardLink';
-import { useGetPanelTypesQueryParam } from 'hooks/queryBuilder/useGetPanelTypesQueryParam';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { useShareBuilderUrl } from 'hooks/queryBuilder/useShareBuilderUrl';
-import {
-	ICurrentQueryData,
-	useHandleExplorerTabChange,
-} from 'hooks/useHandleExplorerTabChange';
-import { useIsAIAssistantEnabled } from 'hooks/useIsAIAssistantEnabled';
-import { useSafeNavigate } from 'hooks/useSafeNavigate';
-import { isEmpty } from 'lodash-es';
-import ErrorBoundaryFallback from 'pages/ErrorBoundaryFallback/ErrorBoundaryFallback';
-import { ExplorerViews } from 'pages/LogsExplorer/utils';
-import {
-	tracesAddFilterAction,
-	tracesChangeViewAction,
-	tracesRunQueryAction,
-	tracesSaveViewAction,
-} from 'pages/TracesExplorer/aiActions';
-import { Warning } from 'types/api';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-import { DataSource } from 'types/common/queryBuilder';
-import {
-	explorerViewToPanelType,
-	getExplorerViewFromUrl,
-} from 'utils/explorerUtils';
-import { v4 } from 'uuid';
-
-import { TOOLBAR_VIEWS } from './constants';
-import ListView from './ListView/ListView';
-import { defaultSelectedColumns } from './ListView/configs';
-import QuerySection from './QuerySection/QuerySection';
-import TableView from './TableView/TableView';
-import TimeSeriesView from './TimeSeriesView/TimeSeriesView';
-import TracesView from './TracesView/TracesView';
-
-import './Explorer.styles.scss';
+import styles from './Explorer.module.scss';
 
+// Shell for the AI Observability Explorer tab. Owns the
+// /ai-observability/explorer route and is intentionally empty for now: the
+// query builder + results surface land in a follow-up.
 function Explorer(): JSX.Element {
-	const {
-		panelType,
-		updateAllQueriesOperators,
-		handleRunQuery,
-		stagedQuery,
-		handleSetConfig,
-		currentQuery,
-		handleSetQueryData,
-		redirectWithQueryBuilderData,
-	} = useQueryBuilder();
-
-	const isAIAssistantEnabled = useIsAIAssistantEnabled();
-
-	const { options } = useOptionsMenu({
-		dataSource: DataSource.TRACES,
-		aggregateOperator: 'noop',
-		initialOptions: {
-			selectColumns: defaultSelectedColumns,
-		},
-	});
-
-	const [searchParams] = useSearchParams();
-	const queryClient = useQueryClient();
-	const listQueryKeyRef = useRef<any>();
-
-	// Get panel type from URL
-	const panelTypesFromUrl = useGetPanelTypesQueryParam(PANEL_TYPES.LIST);
-	const [isLoadingQueries, setIsLoadingQueries] = useState<boolean>(false);
-	const [isCancelled, setIsCancelled] = useState(false);
-
-	useEffect(() => {
-		if (isLoadingQueries) {
-			setIsCancelled(false);
-		}
-	}, [isLoadingQueries]);
-
-	const handleCancelQuery = useCallback(() => {
-		if (listQueryKeyRef.current) {
-			queryClient.cancelQueries(listQueryKeyRef.current);
-		}
-		setIsCancelled(true);
-		// Reset loading state — the active view unmounts when cancelled, so no
-		// child will call setIsLoadingQueries(false) otherwise.
-		setIsLoadingQueries(false);
-	}, [queryClient]);
-
-	const [selectedView, setSelectedView] = useState<ExplorerViews>(() =>
-		getExplorerViewFromUrl(searchParams, panelTypesFromUrl),
-	);
-
-	const [warning, setWarning] = useState<Warning | undefined>();
-	const [isOpen, setOpen] = useState<boolean>(true);
-
-	const defaultQuery = useMemo(
-		(): Query =>
-			updateAllQueriesOperators(
-				initialQueriesMap.traces,
-				PANEL_TYPES.LIST,
-				DataSource.TRACES,
-			),
-		[updateAllQueriesOperators],
-	);
-
-	const { handleExplorerTabChange } = useHandleExplorerTabChange();
-	const { safeNavigate } = useSafeNavigate();
-	const getExportToDashboardLink = useGetExportToDashboardLink();
-
-	const handleChangeSelectedView = useCallback(
-		(view: ExplorerViews, querySearchParameters?: ICurrentQueryData): void => {
-			handleSetConfig(explorerViewToPanelType[view], DataSource.TRACES);
-
-			setSelectedView(view);
-
-			handleExplorerTabChange(
-				explorerViewToPanelType[view],
-				querySearchParameters,
-			);
-		},
-		[handleExplorerTabChange, handleSetConfig],
-	);
-
-	// ─── AI Assistant page actions (only when license feature is on) ───────────
-	const aiActions = useMemo(
-		() =>
-			isAIAssistantEnabled
-				? [
-						tracesRunQueryAction({
-							currentQuery,
-							handleSetQueryData,
-							redirectWithQueryBuilderData,
-						}),
-						tracesAddFilterAction({
-							currentQuery,
-							handleSetQueryData,
-							redirectWithQueryBuilderData,
-						}),
-						tracesChangeViewAction({
-							onChangeView: (view) => handleChangeSelectedView(view as ExplorerViews),
-						}),
-						tracesSaveViewAction({
-							// POC stub — logs a save request; wire to real API when available
-							onSaveView: async (name) => {
-								// eslint-disable-next-line no-console
-								console.info('[AI Assistant] Save view requested:', name);
-							},
-						}),
-					]
-				: [],
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[
-			isAIAssistantEnabled,
-			currentQuery,
-			handleSetQueryData,
-			redirectWithQueryBuilderData,
-			handleChangeSelectedView,
-		],
-	);
-	usePageActions('traces-explorer', aiActions);
-	// ───────────────────────────────────────────────────────────────────────────
-
-	const exportDefaultQuery = useMemo(
-		() =>
-			getQueryByPanelType(
-				stagedQuery || initialQueriesMap.traces,
-				panelType || PANEL_TYPES.LIST,
-			),
-		[stagedQuery, panelType],
-	);
-
-	const handleExport = useCallback(
-		(dashboard: ExportDashboard | null, isNewDashboard?: boolean): void => {
-			if (!dashboard || !panelType) {
-				return;
-			}
-
-			const panelTypeParam = AVAILABLE_EXPORT_PANEL_TYPES.includes(panelType)
-				? panelType
-				: PANEL_TYPES.TIME_SERIES;
-
-			const widgetId = v4();
-
-			const query = getExportQueryData(
-				exportDefaultQuery,
-				panelTypeParam,
-				options,
-			);
-
-			logEvent('Traces Explorer: Add to dashboard successful', {
-				panelType,
-				isNewDashboard,
-				dashboardName: dashboard?.title,
-			});
-
-			const dashboardEditView = getExportToDashboardLink({
-				query,
-				panelType: panelTypeParam,
-				dashboardId: dashboard.id,
-				widgetId,
-			});
-
-			if (dashboardEditView) {
-				safeNavigate(dashboardEditView);
-			}
-		},
-		[
-			exportDefaultQuery,
-			panelType,
-			safeNavigate,
-			options,
-			getExportToDashboardLink,
-		],
-	);
-
-	useShareBuilderUrl({ defaultValue: defaultQuery });
-
-	const logEventCalledRef = useRef(false);
-
-	useEffect(() => {
-		if (!logEventCalledRef.current) {
-			logEvent('Traces Explorer: Page visited', {});
-			logEventCalledRef.current = true;
-		}
-	}, []);
-
-	const isFilterApplied = useMemo(() => {
-		// if any of the non-disabled queries has filters applied, return true
-		const result = stagedQuery?.builder?.queryData?.filter(
-			(item) => !isEmpty(item.filters?.items) && !item.disabled,
-		);
-		return !!result?.length;
-	}, [stagedQuery]);
-
 	return (
-		<Sentry.ErrorBoundary fallback={<ErrorBoundaryFallback />}>
-			<div
-				className="trace-explorer-page"
-				data-testid="llm-observability-explorer"
-			>
-				<Card className="filter" hidden={!isOpen}>
-					<QuickFilters
-						className="qf-traces-explorer"
-						source={QuickFiltersSource.TRACES_EXPLORER}
-						signal={SignalType.TRACES}
-						handleFilterVisibilityChange={(): void => {
-							setOpen(!isOpen);
-						}}
-					/>
-				</Card>
-				<div
-					className={cx('trace-explorer', {
-						'filters-expanded': isOpen,
-					})}
-				>
-					<div className="trace-explorer-header">
-						<Toolbar
-							showAutoRefresh
-							leftActions={
-								<LeftToolbarActions
-									showFilter={isOpen}
-									handleFilterVisibilityChange={(): void => setOpen(!isOpen)}
-									items={TOOLBAR_VIEWS}
-									selectedView={selectedView}
-									onChangeSelectedView={handleChangeSelectedView}
-								/>
-							}
-							warningElement={
-								!isEmpty(warning) ? <WarningPopover warningData={warning} /> : <div />
-							}
-							rightActions={
-								<RightToolbarActions
-									onStageRunQuery={(): void => {
-										setIsCancelled(false);
-										handleRunQuery();
-									}}
-									isLoadingQueries={isLoadingQueries}
-									handleCancelQuery={handleCancelQuery}
-								/>
-							}
-						/>
-					</div>
-					<ExplorerCard sourcepage={DataSource.TRACES}>
-						<div className="query-section-container">
-							<QuerySection />
-						</div>
-					</ExplorerCard>
-
-					<div className="traces-explorer-views">
-						{isCancelled && (
-							<QueryCancelledPlaceholder subText='Click "Run Query" to load traces.' />
-						)}
-
-						{!isCancelled && selectedView === ExplorerViews.LIST && (
-							<div className="trace-explorer-list-view">
-								<ListView
-									isFilterApplied={isFilterApplied}
-									setWarning={setWarning}
-									setIsLoadingQueries={setIsLoadingQueries}
-									queryKeyRef={listQueryKeyRef}
-								/>
-							</div>
-						)}
-
-						{!isCancelled && selectedView === ExplorerViews.TRACE && (
-							<div className="trace-explorer-traces-view">
-								<TracesView
-									isFilterApplied={isFilterApplied}
-									setWarning={setWarning}
-									setIsLoadingQueries={setIsLoadingQueries}
-									queryKeyRef={listQueryKeyRef}
-								/>
-							</div>
-						)}
-
-						{!isCancelled && selectedView === ExplorerViews.TIMESERIES && (
-							<div className="trace-explorer-time-series-view">
-								<TimeSeriesView
-									dataSource={DataSource.TRACES}
-									isFilterApplied={isFilterApplied}
-									setWarning={setWarning}
-									setIsLoadingQueries={setIsLoadingQueries}
-									queryKeyRef={listQueryKeyRef}
-								/>
-							</div>
-						)}
-
-						{!isCancelled && selectedView === ExplorerViews.TABLE && (
-							<div className="trace-explorer-table-view">
-								<TableView
-									setWarning={setWarning}
-									setIsLoadingQueries={setIsLoadingQueries}
-									queryKeyRef={listQueryKeyRef}
-								/>
-							</div>
-						)}
-					</div>
-
-					<ExplorerOptionWrapper
-						disabled={!stagedQuery}
-						query={exportDefaultQuery}
-						sourcepage={DataSource.TRACES}
-						onExport={handleExport}
-						handleChangeSelectedView={handleChangeSelectedView}
-					/>
-				</div>
-			</div>
-		</Sentry.ErrorBoundary>
+		<div className={styles.explorer} data-testid="llm-observability-explorer">
+			<div className={styles.placeholder}>Explorer coming soon.</div>
+		</div>
 	);
 }
 

frontend/src/container/LLMObservability/Explorer/ListView/ListView.module.scss

@@ -1,8 +0,0 @@
-.container {
-	display: flex;
-	flex-direction: column;
-	flex: 1;
-	min-height: 0;
-	height: calc(100vh - 240px);
-	min-height: 400px;
-}

frontend/src/container/LLMObservability/Explorer/ListView/ListView.styles.scss

@@ -1,34 +0,0 @@
-.trace-explorer-controls {
-	display: flex;
-	justify-content: flex-end;
-	align-items: center;
-	gap: 8px;
-
-	.order-by-container {
-		display: flex;
-		align-items: center;
-		gap: 8px;
-
-		.order-by-label {
-			color: var(--muted-foreground);
-			font-size: 12px;
-			font-style: normal;
-			font-weight: 400;
-			line-height: 16px; /* 133.333% */
-
-			display: flex;
-			align-items: center;
-			gap: 4px;
-		}
-
-		.order-by-select {
-			width: 100px;
-
-			.ant-select-selector {
-				border: none;
-				box-shadow: none;
-				background-color: transparent;
-			}
-		}
-	}
-}

frontend/src/container/LLMObservability/Explorer/ListView/ListView.tsx

@@ -1,272 +0,0 @@
-import {
-	Dispatch,
-	memo,
-	MutableRefObject,
-	SetStateAction,
-	useCallback,
-	useEffect,
-	useMemo,
-	useState,
-} from 'react';
-import { QueryKey } from 'react-query';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import logEvent from 'api/common/logEvent';
-import DownloadOptionsMenu from 'components/DownloadOptionsMenu/DownloadOptionsMenu';
-import ListViewOrderBy from 'components/OrderBy/ListViewOrderBy';
-import type { TableColumnDef } from 'components/TanStackTableView/types';
-import { ENTITY_VERSION_V5 } from 'constants/app';
-import { QueryParams } from 'constants/query';
-import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import { useOptionsMenu } from 'container/OptionsMenu';
-import { CustomTimeType } from 'container/TopNav/DateTimeSelectionV2/types';
-import TraceExplorerControls from 'container/TracesExplorer/Controls';
-import { getListViewQuery } from 'container/TracesExplorer/explorerUtils';
-import {
-	getTraceLink,
-	transformSpanRows,
-} from 'container/TracesExplorer/ListView/utils';
-import {
-	getFieldColumn,
-	TracesTableRow,
-} from 'container/TracesExplorer/TracesTable/getFieldColumn';
-import TracesTable from 'container/TracesExplorer/TracesTable/TracesTable';
-import { useGetQueryRange } from 'hooks/queryBuilder/useGetQueryRange';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { Pagination } from 'hooks/queryPagination';
-import { getDefaultPaginationConfig } from 'hooks/queryPagination/utils';
-import useUrlQueryData from 'hooks/useUrlQueryData';
-import { ArrowUp10, Minus } from '@signozhq/icons';
-import { AppState } from 'store/reducers';
-import { Warning } from 'types/api';
-import { DataSource } from 'types/common/queryBuilder';
-import { GlobalReducer } from 'types/reducer/globalTime';
-
-import {
-	defaultSelectedColumns,
-	PER_PAGE_OPTIONS,
-	TIMESTAMP_FIELD,
-} from './configs';
-import './ListView.styles.scss';
-
-import styles from './ListView.module.scss';
-
-interface ListViewProps {
-	isFilterApplied: boolean;
-	setWarning: Dispatch<SetStateAction<Warning | undefined>>;
-	setIsLoadingQueries: Dispatch<SetStateAction<boolean>>;
-	queryKeyRef?: MutableRefObject<QueryKey | undefined>;
-}
-
-function ListView({
-	isFilterApplied,
-	setWarning,
-	setIsLoadingQueries,
-	queryKeyRef,
-}: ListViewProps): JSX.Element {
-	const { stagedQuery, panelType: panelTypeFromQueryBuilder } =
-		useQueryBuilder();
-
-	const panelType = panelTypeFromQueryBuilder || PANEL_TYPES.LIST;
-
-	const [orderBy, setOrderBy] = useState<string>('timestamp:desc');
-
-	const {
-		selectedTime: globalSelectedTime,
-		maxTime,
-		minTime,
-		loading: timeRangeUpdateLoading,
-	} = useSelector<AppState, GlobalReducer>((state) => state.globalTime);
-
-	const { options, config } = useOptionsMenu({
-		dataSource: DataSource.TRACES,
-		aggregateOperator: 'count',
-		initialOptions: {
-			selectColumns: defaultSelectedColumns,
-		},
-	});
-
-	const { queryData: paginationQueryData } = useUrlQueryData<Pagination>(
-		QueryParams.pagination,
-	);
-	const paginationConfig =
-		paginationQueryData ?? getDefaultPaginationConfig(PER_PAGE_OPTIONS);
-
-	const requestQuery = useMemo(
-		() => getListViewQuery(stagedQuery || initialQueriesMap.traces, orderBy),
-		[stagedQuery, orderBy],
-	);
-
-	// Stable sorted-name signature for the queryKey.
-	// - Drag updates selectColumns; raw queryKey would churn on reorder.
-	// - Trace API fetches only listed columns → add/remove must refetch.
-	// - Sorted-name signature: stable on reorder, changes on add/remove.
-	const selectColumnsSignature = useMemo(
-		() =>
-			(options?.selectColumns ?? [])
-				.map((c) => c.name)
-				.sort()
-				.join(','),
-		[options?.selectColumns],
-	);
-
-	const queryKey = useMemo(
-		() => [
-			REACT_QUERY_KEY.GET_QUERY_RANGE,
-			globalSelectedTime,
-			maxTime,
-			minTime,
-			stagedQuery,
-			panelType,
-			paginationConfig,
-			selectColumnsSignature,
-			orderBy,
-		],
-		[
-			stagedQuery,
-			panelType,
-			globalSelectedTime,
-			paginationConfig,
-			selectColumnsSignature,
-			maxTime,
-			minTime,
-			orderBy,
-		],
-	);
-
-	if (queryKeyRef) {
-		queryKeyRef.current = queryKey;
-	}
-
-	const { data, isFetching, isLoading, isError, error } = useGetQueryRange(
-		{
-			query: requestQuery,
-			graphType: panelType,
-			selectedTime: 'GLOBAL_TIME' as const,
-			globalSelectedInterval: globalSelectedTime as CustomTimeType,
-			params: {
-				dataSource: 'traces',
-			},
-			tableParams: {
-				pagination: paginationConfig,
-				selectColumns: options?.selectColumns,
-			},
-		},
-		ENTITY_VERSION_V5,
-		{
-			queryKey,
-			enabled:
-				// don't make api call while the time range state in redux is loading
-				!timeRangeUpdateLoading &&
-				!!stagedQuery &&
-				panelType === PANEL_TYPES.LIST &&
-				!!options?.selectColumns?.length,
-		},
-	);
-
-	useEffect(() => {
-		if (data?.payload) {
-			setWarning(data?.warning);
-		}
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [data?.payload, data?.warning]);
-
-	useEffect(() => {
-		if (isLoading || isFetching) {
-			setIsLoadingQueries(true);
-		} else {
-			setIsLoadingQueries(false);
-		}
-	}, [isLoading, isFetching, setIsLoadingQueries]);
-
-	const queryTableDataResult = data?.payload?.data?.newResult?.data?.result;
-	const queryTableData = useMemo(
-		() => queryTableDataResult || [],
-		[queryTableDataResult],
-	);
-
-	const columns = useMemo<TableColumnDef<TracesTableRow>[]>(() => {
-		const fields = [
-			TIMESTAMP_FIELD,
-			...(options?.selectColumns ?? []).filter(
-				(field) => field.name !== TIMESTAMP_FIELD.name,
-			),
-		];
-		return fields.map((field) => getFieldColumn(field));
-	}, [options?.selectColumns]);
-
-	const rows = useMemo(
-		() => transformSpanRows(queryTableData),
-		[queryTableData],
-	);
-
-	const handleColumnOrderChange = useCallback(
-		(reordered: TableColumnDef<TracesTableRow>[]): void => {
-			config?.addColumn?.onReorder(reordered.map((column) => column.id));
-		},
-		[config],
-	);
-
-	const handleOrderChange = useCallback((value: string) => {
-		setOrderBy(value);
-	}, []);
-
-	useEffect(() => {
-		if (!isLoading && !isFetching && !isError && rows.length !== 0) {
-			void logEvent('Traces Explorer: Data present', {
-				panelType,
-			});
-		}
-	}, [isLoading, isFetching, isError, rows, panelType]);
-
-	return (
-		<div className={styles.container}>
-			<div className="trace-explorer-controls">
-				<div className="order-by-container">
-					<div className="order-by-label">
-						Order by <Minus size={14} /> <ArrowUp10 size={14} />
-					</div>
-
-					<ListViewOrderBy
-						value={orderBy}
-						onChange={handleOrderChange}
-						dataSource={DataSource.TRACES}
-					/>
-				</div>
-
-				<DownloadOptionsMenu
-					dataSource={DataSource.TRACES}
-					selectedColumns={options?.selectColumns}
-				/>
-
-				<TraceExplorerControls
-					isLoading={isFetching}
-					totalCount={rows.length}
-					config={config}
-					perPageOptions={PER_PAGE_OPTIONS}
-				/>
-			</div>
-
-			<TracesTable
-				data={rows}
-				columns={columns}
-				panelType="LIST"
-				getRowHref={getTraceLink}
-				isLoading={isLoading}
-				isFetching={isFetching}
-				isError={isError}
-				error={error}
-				isFilterApplied={isFilterApplied}
-				onColumnOrderChange={handleColumnOrderChange}
-				onColumnRemove={config?.addColumn?.onRemove}
-			/>
-		</div>
-	);
-}
-
-ListView.defaultProps = {
-	queryKeyRef: undefined,
-};
-
-export default memo(ListView);

frontend/src/container/LLMObservability/Explorer/ListView/configs.ts

@@ -1,19 +0,0 @@
-import type { TelemetryFieldKey } from 'api/v5/v5';
-import { DEFAULT_PER_PAGE_OPTIONS } from 'hooks/queryPagination';
-
-export const defaultSelectedColumns: string[] = [
-	'service.name',
-	'name',
-	'duration_nano',
-	'http_method',
-	'response_status_code',
-	'timestamp',
-];
-
-export const PER_PAGE_OPTIONS: number[] = [10, ...DEFAULT_PER_PAGE_OPTIONS];
-
-// Pinned timestamp column
-export const TIMESTAMP_FIELD = {
-	name: 'timestamp',
-	fieldContext: 'span',
-} as TelemetryFieldKey;

frontend/src/container/LLMObservability/Explorer/QuerySection/QuerySection.tsx

@@ -1,61 +0,0 @@
-import { memo, useCallback, useMemo } from 'react';
-import { QueryBuilderV2 } from 'components/QueryBuilderV2/QueryBuilderV2';
-import { PANEL_TYPES } from 'constants/queryBuilder';
-import ExplorerOrderBy from 'container/ExplorerOrderBy';
-import { OrderByFilterProps } from 'container/QueryBuilder/filters/OrderByFilter/OrderByFilter.interfaces';
-import { QueryBuilderProps } from 'container/QueryBuilder/QueryBuilder.interfaces';
-import { useGetPanelTypesQueryParam } from 'hooks/queryBuilder/useGetPanelTypesQueryParam';
-import { DataSource } from 'types/common/queryBuilder';
-
-function QuerySection(): JSX.Element {
-	const panelTypes = useGetPanelTypesQueryParam(PANEL_TYPES.LIST);
-
-	const filterConfigs: QueryBuilderProps['filterConfigs'] = useMemo(() => {
-		const isList = panelTypes === PANEL_TYPES.LIST;
-		const config: QueryBuilderProps['filterConfigs'] = {
-			stepInterval: { isHidden: false, isDisabled: false },
-			limit: { isHidden: isList, isDisabled: true },
-			having: { isHidden: isList, isDisabled: true },
-		};
-
-		return config;
-	}, [panelTypes]);
-
-	const renderOrderBy = useCallback(
-		({ query, onChange }: OrderByFilterProps) => (
-			<ExplorerOrderBy query={query} onChange={onChange} />
-		),
-		[],
-	);
-
-	const queryComponents = useMemo((): QueryBuilderProps['queryComponents'] => {
-		const shouldRenderCustomOrderBy =
-			panelTypes === PANEL_TYPES.LIST || panelTypes === PANEL_TYPES.TRACE;
-
-		return {
-			...(shouldRenderCustomOrderBy ? { renderOrderBy } : {}),
-		};
-	}, [panelTypes, renderOrderBy]);
-
-	const isListViewPanel = useMemo(
-		() => panelTypes === PANEL_TYPES.LIST || panelTypes === PANEL_TYPES.TRACE,
-		[panelTypes],
-	);
-
-	return (
-		<QueryBuilderV2
-			isListViewPanel={isListViewPanel}
-			showTraceOperator
-			config={{ initialDataSource: DataSource.TRACES, queryVariant: 'static' }}
-			queryComponents={queryComponents}
-			panelType={panelTypes}
-			filterConfigs={filterConfigs}
-			showOnlyWhereClause={
-				panelTypes === PANEL_TYPES.LIST || panelTypes === PANEL_TYPES.TRACE
-			}
-			version="v3" // setting this to v3 as we this is rendered in logs explorer
-		/>
-	);
-}
-
-export default memo(QuerySection);

frontend/src/container/LLMObservability/Explorer/TableView/TableView.styles.scss

@@ -1,7 +0,0 @@
-.traces-table-view-header {
-	display: flex;
-	justify-content: flex-end;
-	align-items: center;
-	padding: 12px;
-	flex-shrink: 0;
-}

frontend/src/container/LLMObservability/Explorer/TableView/TableView.tsx

@@ -1,130 +0,0 @@
-import {
-	Dispatch,
-	memo,
-	MutableRefObject,
-	SetStateAction,
-	useEffect,
-	useMemo,
-} from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { Space } from 'antd';
-import ErrorInPlace from 'components/ErrorInPlace/ErrorInPlace';
-import ExportMenu from 'components/ExportMenu/ExportMenu';
-import { ENTITY_VERSION_V5 } from 'constants/app';
-import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import { QueryTable } from 'container/QueryTable';
-import { useGetQueryRange } from 'hooks/queryBuilder/useGetQueryRange';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { AppState } from 'store/reducers';
-import { Warning } from 'types/api';
-import APIError from 'types/api/error';
-import { QueryDataV3 } from 'types/api/widgets/getQuery';
-import { DataSource } from 'types/common/queryBuilder';
-import { GlobalReducer } from 'types/reducer/globalTime';
-
-import './TableView.styles.scss';
-
-function TableView({
-	setWarning,
-	setIsLoadingQueries,
-	queryKeyRef,
-}: {
-	setWarning: Dispatch<SetStateAction<Warning | undefined>>;
-	setIsLoadingQueries: Dispatch<SetStateAction<boolean>>;
-	queryKeyRef?: MutableRefObject<any>;
-}): JSX.Element {
-	const { stagedQuery, panelType } = useQueryBuilder();
-
-	const {
-		selectedTime: globalSelectedTime,
-		maxTime,
-		minTime,
-	} = useSelector<AppState, GlobalReducer>((state) => state.globalTime);
-
-	const queryKey = useMemo(
-		() => [
-			REACT_QUERY_KEY.GET_QUERY_RANGE,
-			globalSelectedTime,
-			maxTime,
-			minTime,
-			stagedQuery,
-		],
-		[globalSelectedTime, maxTime, minTime, stagedQuery],
-	);
-
-	if (queryKeyRef) {
-		queryKeyRef.current = queryKey;
-	}
-
-	const { data, isLoading, isFetching, isError, error } = useGetQueryRange(
-		{
-			query: stagedQuery || initialQueriesMap.traces,
-			graphType: panelType || PANEL_TYPES.TABLE,
-			selectedTime: 'GLOBAL_TIME',
-			globalSelectedInterval: globalSelectedTime,
-			params: {
-				dataSource: 'traces',
-			},
-		},
-		ENTITY_VERSION_V5,
-		{
-			queryKey,
-			enabled: !!stagedQuery && panelType === PANEL_TYPES.TABLE,
-		},
-	);
-
-	useEffect(() => {
-		if (isLoading || isFetching) {
-			setIsLoadingQueries(true);
-		} else {
-			setIsLoadingQueries(false);
-		}
-	}, [isLoading, isFetching, setIsLoadingQueries]);
-
-	const queryTableData = useMemo(
-		() =>
-			data?.payload?.data?.newResult?.data?.result ||
-			data?.payload.data.result ||
-			[],
-		[data],
-	);
-
-	useEffect(() => {
-		if (data?.payload) {
-			setWarning(data.warning);
-		}
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [data?.payload, data?.warning]);
-
-	return (
-		<Space.Compact block direction="vertical">
-			{isError && error && <ErrorInPlace error={error as APIError} />}
-			{!isError && data && (
-				<div className="traces-table-view-header">
-					<ExportMenu
-						dataSource={DataSource.TRACES}
-						data={data}
-						query={stagedQuery || initialQueriesMap.traces}
-						fileName="traces-table"
-					/>
-				</div>
-			)}
-			{!isError && (
-				<QueryTable
-					query={stagedQuery || initialQueriesMap.traces}
-					queryTableData={queryTableData as QueryDataV3[]}
-					loading={isLoading}
-					sticky
-				/>
-			)}
-		</Space.Compact>
-	);
-}
-
-TableView.defaultProps = {
-	queryKeyRef: undefined,
-};
-
-export default memo(TableView);

frontend/src/container/LLMObservability/Explorer/TimeSeriesView/TimeSeriesView.styles.scss

@@ -1,8 +0,0 @@
-.trace-explorer-time-series-view-container {
-	&-header {
-		display: flex;
-		justify-content: flex-start;
-		align-items: center;
-		padding: 12px;
-	}
-}

frontend/src/container/LLMObservability/Explorer/TimeSeriesView/TimeSeriesView.tsx

@@ -1,147 +0,0 @@
-import {
-	Dispatch,
-	MutableRefObject,
-	SetStateAction,
-	useEffect,
-	useMemo,
-} from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { ENTITY_VERSION_V5 } from 'constants/app';
-import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import TimeSeriesView from 'container/TimeSeriesView/TimeSeriesView';
-import { convertDataValueToMs } from 'container/TimeSeriesView/utils';
-import { useGetQueryRange } from 'hooks/queryBuilder/useGetQueryRange';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import useUrlYAxisUnit from 'hooks/useUrlYAxisUnit';
-import { AppState } from 'store/reducers';
-import { Warning } from 'types/api';
-import APIError from 'types/api/error';
-import { DataSource } from 'types/common/queryBuilder';
-import { GlobalReducer } from 'types/reducer/globalTime';
-
-import './TimeSeriesView.styles.scss';
-
-function TimeSeriesViewContainer({
-	dataSource = DataSource.TRACES,
-	isFilterApplied,
-	setWarning,
-	setIsLoadingQueries,
-	queryKeyRef,
-}: TimeSeriesViewProps): JSX.Element {
-	const { stagedQuery, currentQuery, panelType } = useQueryBuilder();
-
-	const isValidToConvertToMs = useMemo(() => {
-		const isValid: boolean[] = [];
-
-		currentQuery.builder.queryData.forEach(
-			({ aggregateAttribute, aggregateOperator }) => {
-				const isExistDurationNanoAttribute =
-					aggregateAttribute?.key === 'durationNano' ||
-					aggregateAttribute?.key === 'duration_nano';
-
-				const isCountOperator =
-					aggregateOperator === 'count' || aggregateOperator === 'count_distinct';
-
-				isValid.push(!isCountOperator && isExistDurationNanoAttribute);
-			},
-		);
-
-		return isValid.every(Boolean);
-	}, [currentQuery]);
-
-	const defaultUnit = isValidToConvertToMs ? 'ms' : 'short';
-	const { yAxisUnit, onUnitChange } = useUrlYAxisUnit(defaultUnit);
-
-	const {
-		selectedTime: globalSelectedTime,
-		maxTime,
-		minTime,
-	} = useSelector<AppState, GlobalReducer>((state) => state.globalTime);
-
-	const queryKey = useMemo(
-		() => [
-			REACT_QUERY_KEY.GET_QUERY_RANGE,
-			globalSelectedTime,
-			maxTime,
-			minTime,
-			stagedQuery,
-		],
-		[globalSelectedTime, maxTime, minTime, stagedQuery],
-	);
-
-	if (queryKeyRef) {
-		queryKeyRef.current = queryKey;
-	}
-
-	const { data, isLoading, isFetching, isError, error } = useGetQueryRange(
-		{
-			query: stagedQuery || initialQueriesMap[dataSource],
-			graphType: panelType || PANEL_TYPES.TIME_SERIES,
-			selectedTime: 'GLOBAL_TIME',
-			globalSelectedInterval: globalSelectedTime,
-			params: {
-				dataSource,
-			},
-		},
-		// ENTITY_VERSION_V4,
-		ENTITY_VERSION_V5,
-		{
-			queryKey,
-			enabled: !!stagedQuery && panelType === PANEL_TYPES.TIME_SERIES,
-		},
-	);
-
-	useEffect(() => {
-		if (data?.payload) {
-			setWarning(data?.warning);
-		}
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [data?.payload, data?.warning]);
-
-	const responseData = useMemo(
-		() => (isValidToConvertToMs ? convertDataValueToMs(data) : data),
-		[data, isValidToConvertToMs],
-	);
-
-	useEffect(() => {
-		if (isLoading || isFetching) {
-			setIsLoadingQueries(true);
-		} else {
-			setIsLoadingQueries(false);
-		}
-	}, [isLoading, isFetching, setIsLoadingQueries]);
-
-	return (
-		<div className="trace-explorer-time-series-view-container">
-			<TimeSeriesView
-				isFilterApplied={isFilterApplied}
-				isError={isError}
-				error={error as APIError}
-				isLoading={isLoading || isFetching}
-				data={responseData}
-				yAxisUnit={yAxisUnit}
-				onYAxisUnitChange={onUnitChange}
-				dataSource={dataSource}
-				setWarning={setWarning}
-				allowExport
-			/>
-		</div>
-	);
-}
-
-interface TimeSeriesViewProps {
-	dataSource?: DataSource;
-	isFilterApplied: boolean;
-	setWarning: Dispatch<SetStateAction<Warning | undefined>>;
-	setIsLoadingQueries: Dispatch<SetStateAction<boolean>>;
-	queryKeyRef?: MutableRefObject<any>;
-}
-
-TimeSeriesViewContainer.defaultProps = {
-	dataSource: DataSource.TRACES,
-	queryKeyRef: undefined,
-};
-
-export default TimeSeriesViewContainer;

frontend/src/container/LLMObservability/Explorer/TracesView/TracesView.module.scss

@@ -1,15 +0,0 @@
-.container {
-	display: flex;
-	flex-direction: column;
-	flex: 1;
-	min-height: 0;
-	// Page chain isn't a flex column, so anchor the virtualized table against the viewport.
-	height: calc(100vh - 240px);
-	min-height: 400px;
-}
-
-.actionsContainer {
-	display: flex;
-	justify-content: space-between;
-	align-items: center;
-}

frontend/src/container/LLMObservability/Explorer/TracesView/TracesView.tsx

@@ -1,190 +0,0 @@
-import {
-	Dispatch,
-	memo,
-	MutableRefObject,
-	SetStateAction,
-	useEffect,
-	useMemo,
-} from 'react';
-import { QueryKey } from 'react-query';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { Typography } from '@signozhq/ui/typography';
-import logEvent from 'api/common/logEvent';
-import DownloadOptionsMenu from 'components/DownloadOptionsMenu/DownloadOptionsMenu';
-import { ENTITY_VERSION_V5 } from 'constants/app';
-import { QueryParams } from 'constants/query';
-import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import TraceExplorerControls from 'container/TracesExplorer/Controls';
-import { getListViewQuery } from 'container/TracesExplorer/explorerUtils';
-import { getTraceLink } from 'container/TracesExplorer/ListView/utils';
-import { TracesTableRow } from 'container/TracesExplorer/TracesTable/getFieldColumn';
-import TracesTable from 'container/TracesExplorer/TracesTable/TracesTable';
-import { useGetQueryRange } from 'hooks/queryBuilder/useGetQueryRange';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { Pagination } from 'hooks/queryPagination';
-import useUrlQueryData from 'hooks/useUrlQueryData';
-import { AppState } from 'store/reducers';
-import { Warning } from 'types/api';
-import { DataSource } from 'types/common/queryBuilder';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import DOCLINKS from 'utils/docLinks';
-
-import { columns, PER_PAGE_OPTIONS } from './configs';
-import styles from './TracesView.module.scss';
-
-interface TracesViewProps {
-	isFilterApplied: boolean;
-	setWarning: Dispatch<SetStateAction<Warning | undefined>>;
-	setIsLoadingQueries: Dispatch<SetStateAction<boolean>>;
-	queryKeyRef?: MutableRefObject<QueryKey | undefined>;
-}
-
-function TracesView({
-	isFilterApplied,
-	setWarning,
-	setIsLoadingQueries,
-	queryKeyRef,
-}: TracesViewProps): JSX.Element {
-	const { stagedQuery, panelType } = useQueryBuilder();
-
-	const {
-		selectedTime: globalSelectedTime,
-		maxTime,
-		minTime,
-	} = useSelector<AppState, GlobalReducer>((state) => state.globalTime);
-
-	const { queryData: paginationQueryData } = useUrlQueryData<Pagination>(
-		QueryParams.pagination,
-	);
-
-	const transformedQuery = useMemo(
-		() => getListViewQuery(stagedQuery || initialQueriesMap.traces),
-		[stagedQuery],
-	);
-
-	const queryKey = useMemo(
-		() => [
-			REACT_QUERY_KEY.GET_QUERY_RANGE,
-			globalSelectedTime,
-			maxTime,
-			minTime,
-			stagedQuery,
-			panelType,
-			paginationQueryData,
-		],
-		[
-			globalSelectedTime,
-			maxTime,
-			minTime,
-			stagedQuery,
-			panelType,
-			paginationQueryData,
-		],
-	);
-
-	if (queryKeyRef) {
-		queryKeyRef.current = queryKey;
-	}
-
-	const { data, isLoading, isFetching, isError, error } = useGetQueryRange(
-		{
-			query: transformedQuery,
-			graphType: panelType || PANEL_TYPES.TRACE,
-			selectedTime: 'GLOBAL_TIME',
-			globalSelectedInterval: globalSelectedTime,
-			params: {
-				dataSource: 'traces',
-			},
-			tableParams: {
-				pagination: paginationQueryData,
-			},
-		},
-		ENTITY_VERSION_V5,
-		{
-			queryKey,
-			enabled: !!stagedQuery && panelType === PANEL_TYPES.TRACE,
-		},
-	);
-
-	useEffect(() => {
-		if (data?.payload) {
-			setWarning(data?.warning);
-		}
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [data?.payload, data?.warning]);
-
-	const responseData = data?.payload?.data?.newResult?.data?.result[0]?.list;
-
-	const rows = useMemo<TracesTableRow[]>(
-		() =>
-			(responseData ?? []).map((item) => {
-				const row = item.data;
-				return { ...row, id: row.trace_id };
-			}) as TracesTableRow[],
-		[responseData],
-	);
-
-	useEffect(() => {
-		if (isLoading || isFetching) {
-			setIsLoadingQueries(true);
-		} else {
-			setIsLoadingQueries(false);
-		}
-	}, [isLoading, isFetching, setIsLoadingQueries]);
-
-	useEffect(() => {
-		if (!isLoading && !isFetching && !isError && rows.length !== 0) {
-			void logEvent('Traces Explorer: Data present', {
-				panelType: 'TRACE',
-			});
-		}
-	}, [isLoading, isFetching, isError, rows.length]);
-
-	return (
-		<div className={styles.container}>
-			<div className={styles.actionsContainer}>
-				<Typography>
-					This tab only shows Root Spans. More details
-					<Typography.Link href={DOCLINKS.TRACES_DETAILS_LINK} target="_blank">
-						{' '}
-						here
-					</Typography.Link>
-				</Typography>
-
-				<div className="trace-explorer-controls">
-					<DownloadOptionsMenu
-						dataSource={DataSource.TRACES}
-						panelType={PANEL_TYPES.TRACE}
-					/>
-
-					<TraceExplorerControls
-						isLoading={isLoading}
-						totalCount={rows.length}
-						perPageOptions={PER_PAGE_OPTIONS}
-					/>
-				</div>
-			</div>
-
-			<TracesTable
-				data={rows}
-				columns={columns}
-				respectColumnOrder
-				panelType="TRACE"
-				getRowHref={getTraceLink}
-				isLoading={isLoading}
-				isFetching={isFetching}
-				isError={isError}
-				error={error}
-				isFilterApplied={isFilterApplied}
-			/>
-		</div>
-	);
-}
-
-TracesView.defaultProps = {
-	queryKeyRef: undefined,
-};
-
-export default memo(TracesView);

frontend/src/container/LLMObservability/Explorer/TracesView/configs.ts

@@ -1,25 +0,0 @@
-import { TelemetryFieldKey } from 'api/v5/v5';
-import type { TableColumnDef } from 'components/TanStackTableView/types';
-import {
-	getFieldColumn,
-	TracesTableRow,
-} from 'container/TracesExplorer/TracesTable/getFieldColumn';
-import { DEFAULT_PER_PAGE_OPTIONS } from 'hooks/queryPagination';
-
-export const PER_PAGE_OPTIONS: number[] = [10, ...DEFAULT_PER_PAGE_OPTIONS];
-
-const TRACE_FIELDS = [
-	{ name: 'service.name', fieldContext: 'resource' },
-	{ name: 'name' },
-	{ name: 'duration_nano' },
-	{ name: 'span_count' },
-	{ name: 'trace_id' },
-] as TelemetryFieldKey[];
-
-export const columns: TableColumnDef<TracesTableRow>[] = TRACE_FIELDS.map(
-	(field) => ({
-		...getFieldColumn(field),
-		enableRemove: false,
-		canBeHidden: false,
-	}),
-);

frontend/src/container/LLMObservability/Explorer/constants.ts

@@ -1,36 +0,0 @@
-export const TOOLBAR_VIEWS = {
-	list: {
-		name: 'list',
-		label: 'List',
-		show: true,
-		key: 'list',
-	},
-	timeseries: {
-		name: 'timeseries',
-		label: 'Timeseries',
-		disabled: false,
-		show: true,
-		key: 'timeseries',
-	},
-	trace: {
-		name: 'trace',
-		label: 'Trace',
-		disabled: false,
-		show: true,
-		key: 'trace',
-	},
-	table: {
-		name: 'table',
-		label: 'Table',
-		disabled: false,
-		show: true,
-		key: 'table',
-	},
-	clickhouse: {
-		name: 'clickhouse',
-		label: 'Clickhouse',
-		disabled: false,
-		show: false,
-		key: 'clickhouse',
-	},
-};

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

@@ -18,12 +18,6 @@ jest.mock('pages/DashboardPageV2/DashboardContainer', () => ({
 	default: (): JSX.Element => <div data-testid="llm-overview-dashboard" />,
 }));
 
-// Same data-router gap as the dashboard above: the Explorer toolbar calls useNavigationType.
-jest.mock('container/LLMObservability/Explorer/Explorer', () => ({
-	__esModule: true,
-	default: (): JSX.Element => <div data-testid="llm-observability-explorer" />,
-}));
-
 function setupList(items = mockRules): void {
 	server.use(
 		rest.get(LLM_PRICING_ENDPOINT, (_req, res, ctx) =>

frontend/src/container/Licenses/ApplyLicenseForm.tsx

@@ -2,9 +2,9 @@ import { useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Input } from '@signozhq/ui/input';
 import { Button, Form } from 'antd';
-import { activateLicense } from 'api/generated/services/licenses';
+import apply from 'api/v3/licenses/post';
 import { useNotifications } from 'hooks/useNotifications';
-import { toAPIError } from 'utils/errorUtils';
+import APIError from 'types/api/error';
 import { requireErrorMessage } from 'utils/form/requireErrorMessage';
 
 import {
@@ -26,7 +26,7 @@ function ApplyLicenseForm({
 
 	const isDisabled = isLoading || !key;
 
-	const onFinish = async (values: unknown): Promise<void> => {
+	const onFinish = async (values: unknown | { key: string }): Promise<void> => {
 		const params = values as { key: string };
 		if (params.key === '' || !params.key) {
 			notifications.error({
@@ -38,19 +38,18 @@ function ApplyLicenseForm({
 
 		setIsLoading(true);
 		try {
-			await activateLicense({
+			await apply({
 				key: params.key,
 			});
-			licenseRefetch();
+			await Promise.all([licenseRefetch()]);
 			notifications.success({
 				message: 'Success',
 				description: t('license_applied'),
 			});
 		} catch (e) {
-			const apiError = toAPIError(e as Parameters<typeof toAPIError>[0]);
 			notifications.error({
-				message: apiError.getErrorCode(),
-				description: apiError.getErrorMessage(),
+				message: (e as APIError).getErrorCode(),
+				description: (e as APIError).getErrorMessage(),
 			});
 		}
 		setIsLoading(false);

frontend/src/container/LiveLogs/LiveLogsList/LiveLogsList.styles.scss

@@ -4,6 +4,13 @@
 			padding: 0px 8px;
 
 			.logs-frequency-chart {
+				.ant-card-body {
+					height: 140px;
+					min-height: 140px;
+					padding: 0 16px 22px 16px;
+					font-family: 'Geist Mono';
+				}
+
 				margin-bottom: 0px;
 			}
 		}

frontend/src/container/LogDetailedView/BodyTitleRenderer.tsx

@@ -15,8 +15,9 @@ import {
 	QUERY_BUILDER_FUNCTIONS,
 } from 'constants/antlrQueryConstants';
 import { FeatureKeys } from 'constants/features';
+import { QueryParams } from 'constants/query';
 import { useActiveLog } from 'hooks/logs/useActiveLog';
-import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
+import { useGetSearchQueryParam } from 'hooks/queryBuilder/useGetSearchQueryParam';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { ICurrentQueryData } from 'hooks/useHandleExplorerTabChange';
 import { useNotifications } from 'hooks/useNotifications';
@@ -49,7 +50,7 @@ function BodyTitleRenderer({
 	const { featureFlags } = useAppContext();
 	const [, setCopy] = useCopyToClipboard();
 	const { notifications } = useNotifications();
-	const { viewName } = useGetSavedViewParams();
+	const viewName = useGetSearchQueryParam(QueryParams.viewName) || '';
 
 	const cleanedNodeKey = removeObjectFromString(nodeKey);
 	const isBodyJsonQueryEnabled =

frontend/src/container/LogDetailedView/TableView/TableViewActions.tsx

@@ -7,12 +7,13 @@ import GroupByIcon from 'assets/CustomIcons/GroupByIcon';
 import cx from 'classnames';
 import CopyClipboardHOC from 'components/Logs/CopyClipboardHOC';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
+import { QueryParams } from 'constants/query';
 import { OPERATORS } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
 import { ChangeViewFunctionType } from 'container/ExplorerOptions/types';
 import { RESTRICTED_SELECTED_FIELDS } from 'container/LogsFilters/config';
 import { MetricsType } from 'container/MetricsApplication/constant';
-import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
+import { useGetSearchQueryParam } from 'hooks/queryBuilder/useGetSearchQueryParam';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { ICurrentQueryData } from 'hooks/useHandleExplorerTabChange';
 import {
@@ -140,7 +141,7 @@ export default function TableViewActions(
 
 	const { pathname } = useLocation();
 	const { stagedQuery, updateQueriesData } = useQueryBuilder();
-	const { viewName } = useGetSavedViewParams();
+	const viewName = useGetSearchQueryParam(QueryParams.viewName) || '';
 	const { dataType, logType: fieldType } = getFieldAttributes(record.field);
 
 	// there is no option for where clause in old logs explorer and live logs page or infra monitoring

frontend/src/container/LogDetailedView/TableView/__test__/TableViewActions.test.tsx

@@ -1,6 +1,6 @@
 import { fireEvent, render, screen } from '@testing-library/react';
 import { RESTRICTED_SELECTED_FIELDS } from 'container/LogsFilters/config';
-import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
+import { useGetSearchQueryParam } from 'hooks/queryBuilder/useGetSearchQueryParam';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { ExplorerViews } from 'pages/LogsExplorer/utils';
 
@@ -88,7 +88,7 @@ jest.mock('react-router-dom', () => ({
 }));
 
 jest.mock('hooks/queryBuilder/useQueryBuilder');
-jest.mock('hooks/saveViews/useGetSavedViewParams');
+jest.mock('hooks/queryBuilder/useGetSearchQueryParam');
 
 describe('TableViewActions', () => {
 	const TEST_VALUE = 'test value';
@@ -140,10 +140,8 @@ describe('TableViewActions', () => {
 			}),
 		} as any);
 
-		// Default mock for useGetSavedViewParams
-		jest
-			.mocked(useGetSavedViewParams)
-			.mockReturnValue({ viewName: '', viewKey: '' });
+		// Default mock for useGetSearchQueryParam
+		jest.mocked(useGetSearchQueryParam).mockReturnValue(null);
 	});
 
 	it('should render without crashing', () => {
@@ -251,9 +249,7 @@ describe('TableViewActions', () => {
 			updateQueriesData: mockUpdateQueriesData,
 		} as any);
 
-		jest
-			.mocked(useGetSavedViewParams)
-			.mockReturnValue({ viewName: '', viewKey: '' });
+		jest.mocked(useGetSearchQueryParam).mockReturnValue(null);
 
 		render(
 			<TableViewActions

frontend/src/container/LogDetailedView/hooks/useLogAttributeActions.tsx

@@ -3,9 +3,10 @@ import { useLocation } from 'react-router-dom';
 import { CircleMinus, CirclePlus, Layers, RefreshCw } from '@signozhq/icons';
 import { convertFiltersToExpression } from 'components/QueryBuilderV2/utils';
 import { FeatureKeys } from 'constants/features';
+import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
 import { ChangeViewFunctionType } from 'container/ExplorerOptions/types';
-import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
+import { useGetSearchQueryParam } from 'hooks/queryBuilder/useGetSearchQueryParam';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { ICurrentQueryData } from 'hooks/useHandleExplorerTabChange';
 import { ExplorerViews } from 'pages/LogsExplorer/utils';
@@ -57,7 +58,7 @@ export function useLogAttributeActions({
 	const { pathname } = useLocation();
 	const { stagedQuery, updateQueriesData } = useQueryBuilder();
 	const { featureFlags } = useAppContext();
-	const { viewName } = useGetSavedViewParams();
+	const viewName = useGetSearchQueryParam(QueryParams.viewName) || '';
 
 	const isBodyJsonQueryEnabled =
 		featureFlags?.find((flag) => flag.name === FeatureKeys.USE_JSON_BODY)

frontend/src/container/LogsExplorerChart/LogsExplorerChart.styles.scss

@@ -3,6 +3,13 @@
 	min-height: 200px;
 	border-bottom: 1px solid var(--l1-border);
 
+	.ant-card-body {
+		height: 200px;
+		min-height: 200px;
+		padding: 0 16px 16px 16px;
+		font-family: 'Geist Mono';
+	}
+
 	.logs-frequency-chart-loading {
 		height: 100%;
 		display: flex;

frontend/src/container/LogsExplorerChart/index.tsx

@@ -1,29 +1,25 @@
-import { memo, useCallback, useMemo, useRef } from 'react';
+import { memo, useCallback, useMemo } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useDispatch, useSelector } from 'react-redux';
 import { useLocation } from 'react-router-dom';
+import Graph from 'components/Graph';
 import Spinner from 'components/Spinner';
 import { QueryParams } from 'constants/query';
-import BarChart from 'container/DashboardContainer/visualization/charts/BarChart/BarChart';
-import { useResizeObserver } from 'hooks/useDimensions';
+import { themeColors } from 'constants/theme';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
+import getChartData, { GetChartDataProps } from 'lib/getChartData';
 import GetMinMax from 'lib/getMinMax';
-import { LegendPosition } from 'lib/uPlotV2/components/types';
-import { StackMode } from 'lib/uPlotV2/config/types';
-import { useTimezone } from 'providers/Timezone';
+import { colors } from 'lib/getRandomColor';
 import { UpdateTimeInterval } from 'store/actions';
 import { AppState } from 'store/reducers';
 import { GlobalReducer } from 'types/reducer/globalTime';
 
 import { LogsExplorerChartProps } from './LogsExplorerChart.interfaces';
-import { useLogsExplorerChartConfig } from './useLogsExplorerChartConfig';
+import { getColorsForSeverityLabels } from './utils';
 
 import './LogsExplorerChart.styles.scss';
 
-// Axis and tooltip format separately; both need this or only one abbreviates.
-const Y_AXIS_UNIT = 'short';
-
 function LogsExplorerChart({
 	data,
 	isLoading,
@@ -41,6 +37,24 @@ function LogsExplorerChart({
 	const { minTime, maxTime } = useSelector<AppState, GlobalReducer>(
 		(state) => state.globalTime,
 	);
+	const handleCreateDatasets: Required<GetChartDataProps>['createDataset'] =
+		useCallback(
+			(element, index, allLabels) => ({
+				data: element,
+				backgroundColor: isLogsExplorerViews
+					? getColorsForSeverityLabels(allLabels[index], index)
+					: colors[index % colors.length] || themeColors.red,
+				borderColor: isLogsExplorerViews
+					? getColorsForSeverityLabels(allLabels[index], index)
+					: colors[index % colors.length] || themeColors.red,
+				...(isLabelEnabled
+					? {
+							label: allLabels[index],
+						}
+					: {}),
+			}),
+			[isLabelEnabled, isLogsExplorerViews],
+		);
 
 	const onDragSelect = useCallback(
 		(start: number, end: number): void => {
@@ -72,47 +86,44 @@ function LogsExplorerChart({
 		[dispatch, location.pathname, safeNavigate, urlQuery, isShowingLiveLogs],
 	);
 
-	// uPlot plots the series on a seconds-based x scale
-	const { minTimeScale, maxTimeScale } = useMemo(
+	const graphData = useMemo(
+		() =>
+			getChartData({
+				queryData: [
+					{
+						queryData: data,
+					},
+				],
+				createDataset: handleCreateDatasets,
+			}),
+		[data, handleCreateDatasets],
+	);
+
+	// Convert nanosecond timestamps to milliseconds for Chart.js
+	const { chartMinTime, chartMaxTime } = useMemo(
 		() => ({
-			minTimeScale: minTime ? Math.floor(minTime / 1e9) : undefined,
-			maxTimeScale: maxTime ? Math.floor(maxTime / 1e9) : undefined,
+			chartMinTime: minTime ? Math.floor(minTime / 1e6) : undefined,
+			chartMaxTime: maxTime ? Math.floor(maxTime / 1e6) : undefined,
 		}),
 		[minTime, maxTime],
 	);
 
-	const { timezone } = useTimezone();
-	const graphRef = useRef<HTMLDivElement>(null);
-	const dimensions = useResizeObserver(graphRef);
-
-	const { config, chartData } = useLogsExplorerChartConfig({
-		data,
-		isLogsExplorerViews,
-		isLabelEnabled,
-		onDragSelect,
-		minTimeScale,
-		maxTimeScale,
-		yAxisUnit: Y_AXIS_UNIT,
-	});
-
 	return (
-		<div ref={graphRef} className={`${className} logs-frequency-chart-container`}>
+		<div className={`${className} logs-frequency-chart-container`}>
 			{isLoading ? (
 				<div className="logs-frequency-chart-loading">
 					<Spinner size="default" height="100%" />
 				</div>
 			) : (
-				<BarChart
-					config={config}
-					data={chartData}
-					width={dimensions.width}
-					height={dimensions.height}
-					stack={isLogsExplorerViews ? StackMode.Normal : StackMode.None}
-					showLegend={isLabelEnabled}
-					legendConfig={{ position: LegendPosition.BOTTOM }}
-					timezone={timezone}
-					data-testid="logs-frequency-chart"
-					yAxisUnit={Y_AXIS_UNIT}
+				<Graph
+					name="logsExplorerChart"
+					data={graphData.data}
+					isStacked={isLogsExplorerViews}
+					type="bar"
+					animate
+					onDragSelect={onDragSelect}
+					minTime={chartMinTime}
+					maxTime={chartMaxTime}
 				/>
 			)}
 		</div>

frontend/src/container/LogsExplorerChart/useLogsExplorerChartConfig.ts

@@ -1,105 +0,0 @@
-import { useMemo } from 'react';
-import { PANEL_TYPES } from 'constants/queryBuilder';
-import { themeColors } from 'constants/theme';
-import { buildBaseConfig } from 'container/DashboardContainer/visualization/panels/utils/baseConfigBuilder';
-import { useIsDarkMode } from 'hooks/useDarkMode';
-import getLabelName from 'lib/getLabelName';
-import { colors } from 'lib/getRandomColor';
-import { getUPlotChartData } from 'lib/uPlotLib/utils/getUplotChartData';
-import { DrawStyle } from 'lib/uPlotV2/config/types';
-import { UPlotConfigBuilder } from 'lib/uPlotV2/config/UPlotConfigBuilder';
-import { useTimezone } from 'providers/Timezone';
-import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
-import { QueryData } from 'types/api/widgets/getQuery';
-import uPlot from 'uplot';
-
-import { getColorsForSeverityLabels } from './utils';
-
-export interface UseLogsExplorerChartConfigParams {
-	data: QueryData[];
-	isLogsExplorerViews?: boolean;
-	isLabelEnabled?: boolean;
-	onDragSelect: (start: number, end: number) => void;
-	minTimeScale?: number;
-	maxTimeScale?: number;
-	yAxisUnit?: string;
-}
-
-export interface UseLogsExplorerChartConfigResult {
-	config: UPlotConfigBuilder;
-	chartData: uPlot.AlignedData;
-}
-
-export function useLogsExplorerChartConfig({
-	data,
-	isLogsExplorerViews = false,
-	isLabelEnabled = true,
-	onDragSelect,
-	minTimeScale,
-	maxTimeScale,
-	yAxisUnit,
-}: UseLogsExplorerChartConfigParams): UseLogsExplorerChartConfigResult {
-	const isDarkMode = useIsDarkMode();
-	const { timezone } = useTimezone();
-
-	// getUPlotChartData / buildBaseConfig both consume the legacy query-range payload
-	// shape, so the raw series list is wrapped instead of being plotted directly.
-	const apiResponse = useMemo(
-		() =>
-			({
-				data: { result: data, resultType: '' },
-			}) as unknown as MetricRangePayloadProps,
-		[data],
-	);
-
-	const chartData = useMemo(() => getUPlotChartData(apiResponse), [apiResponse]);
-
-	const config = useMemo(() => {
-		const builder = buildBaseConfig({
-			id: 'logs-explorer-frequency-chart',
-			isDarkMode,
-			onDragSelect,
-			timezone,
-			minTimeScale,
-			maxTimeScale,
-			yAxisUnit,
-			panelType: PANEL_TYPES.BAR,
-		});
-
-		data.forEach((series, index) => {
-			const label = getLabelName(
-				series.metric,
-				series.queryName || '',
-				series.legend || '',
-			);
-
-			const color = isLogsExplorerViews
-				? getColorsForSeverityLabels(label, index)
-				: colors[index % colors.length] || themeColors.red;
-
-			builder.addSeries({
-				scaleKey: 'y',
-				drawStyle: DrawStyle.Bar,
-				// No group-by yields query name "A"; use ' ' not '' so uPlot does not default the label to "Value".
-				label: isLabelEnabled && label.trim() ? label : ' ',
-				lineColor: color,
-				colorMapping: {},
-				isDarkMode,
-			});
-		});
-
-		return builder;
-	}, [
-		data,
-		isDarkMode,
-		isLabelEnabled,
-		isLogsExplorerViews,
-		maxTimeScale,
-		minTimeScale,
-		onDragSelect,
-		timezone,
-		yAxisUnit,
-	]);
-
-	return { config, chartData };
-}

frontend/src/container/LogsExplorerViews/LogsExplorerViews.styles.scss

@@ -217,6 +217,13 @@
 		padding: 0px 8px;
 
 		.logs-frequency-chart {
+			.ant-card-body {
+				height: 140px;
+				min-height: 140px;
+				padding: 0 16px 22px 16px;
+				font-family: 'Geist Mono';
+			}
+
 			margin-bottom: 0px;
 		}
 	}

frontend/src/container/MySettings/LicenseSection/LicenseSection.tsx

@@ -3,13 +3,13 @@ import { Button } from '@signozhq/ui/button';
 import { Typography } from '@signozhq/ui/typography';
 import { useNotifications } from 'hooks/useNotifications';
 import { Copy } from '@signozhq/icons';
-import useActiveLicenseKey from 'hooks/useActiveLicenseKey/useActiveLicenseKey';
+import { useAppContext } from 'providers/App/App';
 import { getMaskedKey } from 'utils/maskedKey';
 
 import './LicenseSection.styles.scss';
 
 function LicenseSection(): JSX.Element | null {
-	const { licenseKey } = useActiveLicenseKey();
+	const { activeLicense } = useAppContext();
 	const { notifications } = useNotifications();
 	const [, handleCopyToClipboard] = useCopyToClipboard();
 
@@ -20,7 +20,7 @@ function LicenseSection(): JSX.Element | null {
 		});
 	};
 
-	if (!licenseKey) {
+	if (!activeLicense?.key) {
 		return <></>;
 	}
 
@@ -35,13 +35,13 @@ function LicenseSection(): JSX.Element | null {
 					<div className="license-section-content-item-title-action">
 						<span>License key</span>
 						<span style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
-							<Typography.Text code>{getMaskedKey(licenseKey)}</Typography.Text>
+							<Typography.Text code>{getMaskedKey(activeLicense.key)}</Typography.Text>
 							<Button
 								variant="link"
 								color="none"
 								aria-label="Copy license key"
 								data-testid="license-key-copy-btn"
-								onClick={(): void => handleCopyKey(licenseKey)}
+								onClick={(): void => handleCopyKey(activeLicense.key)}
 							>
 								<Copy size={14} />
 							</Button>

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

@@ -1,6 +1,5 @@
 import userEvent from '@testing-library/user-event';
 import MySettingsContainer from 'container/MySettings';
-import useActiveLicenseKey from 'hooks/useActiveLicenseKey/useActiveLicenseKey';
 import { logEventMock } from '__tests__/logEventMock';
 import {
 	act,
@@ -13,11 +12,6 @@ import {
 import APIError from 'types/api/error';
 import { toast } from '@signozhq/ui/sonner';
 
-jest.mock('hooks/useActiveLicenseKey/useActiveLicenseKey');
-const mockUseActiveLicenseKey = useActiveLicenseKey as jest.MockedFunction<
-	typeof useActiveLicenseKey
->;
-
 const toggleThemeFunction = jest.fn();
 const copyToClipboardFn = jest.fn();
 const editUserFn = jest.fn();
@@ -93,10 +87,6 @@ describe('MySettings Flows', () => {
 		jest.clearAllMocks();
 		editUserFn.mockResolvedValue({});
 		updateMyPasswordFn.mockResolvedValue({});
-		mockUseActiveLicenseKey.mockReturnValue({
-			licenseKey: 'test-key',
-			isLoading: false,
-		});
 		render(<MySettingsContainer />);
 	});
 
@@ -378,11 +368,11 @@ describe('MySettings Flows', () => {
 		});
 
 		it('Should not render license section when license key is missing', () => {
-			mockUseActiveLicenseKey.mockReturnValue({
-				licenseKey: undefined,
-				isLoading: false,
+			const { container } = render(<MySettingsContainer />, undefined, {
+				appContextOverrides: {
+					activeLicense: null,
+				},
 			});
-			const { container } = render(<MySettingsContainer />);
 
 			const scoped = within(container);
 			expect(scoped.queryByText('License')).not.toBeInTheDocument();
@@ -393,32 +383,38 @@ describe('MySettings Flows', () => {
 		});
 
 		it('Should mask license key in the UI', () => {
-			mockUseActiveLicenseKey.mockReturnValue({
-				licenseKey: 'abcd',
-				isLoading: false,
+			const { container } = render(<MySettingsContainer />, undefined, {
+				appContextOverrides: {
+					activeLicense: {
+						key: 'abcd',
+					} as any,
+				},
 			});
-			const { container } = render(<MySettingsContainer />);
 
 			expect(within(container).getByText('ab·······cd')).toBeInTheDocument();
 		});
 
 		it('Should not mask license key if it is too short', () => {
-			mockUseActiveLicenseKey.mockReturnValue({
-				licenseKey: 'abc',
-				isLoading: false,
+			const { container } = render(<MySettingsContainer />, undefined, {
+				appContextOverrides: {
+					activeLicense: {
+						key: 'abc',
+					} as any,
+				},
 			});
-			const { container } = render(<MySettingsContainer />);
 
 			expect(within(container).getByText('abc')).toBeInTheDocument();
 		});
 
 		it('Should copy license key and show success toast', async () => {
 			const user = userEvent.setup();
-			mockUseActiveLicenseKey.mockReturnValue({
-				licenseKey: 'test-license-key-12345',
-				isLoading: false,
+			const { container } = render(<MySettingsContainer />, undefined, {
+				appContextOverrides: {
+					activeLicense: {
+						key: 'test-license-key-12345',
+					} as any,
+				},
 			});
-			const { container } = render(<MySettingsContainer />);
 
 			await user.click(within(container).getByTestId('license-key-copy-btn'));
 

frontend/src/container/RolesSettings/hooks/__tests__/useRolePermissions.test.ts

@@ -329,12 +329,11 @@ describe('transformTransactionGroupsToResourcePermissions', () => {
 	it('returns all resources from RESOURCE_ORDER even with empty transaction groups', () => {
 		const result = transformTransactionGroupsToResourcePermissions([]);
 
-		expect(result).toHaveLength(8);
+		expect(result).toHaveLength(7);
 		expect(result.map((r) => r.resourceKind)).toStrictEqual([
 			'factor-api-key',
 			'role',
 			'serviceaccount',
-			'license',
 			'logs',
 			'traces',
 			'metrics',
@@ -419,12 +418,11 @@ describe('createEmptyRolePermissions', () => {
 	it('creates permissions for all resources in RESOURCE_ORDER', () => {
 		const result = createEmptyRolePermissions();
 
-		expect(result).toHaveLength(8);
+		expect(result).toHaveLength(7);
 		expect(result.map((r) => r.resourceKind)).toStrictEqual([
 			'factor-api-key',
 			'role',
 			'serviceaccount',
-			'license',
 			'logs',
 			'traces',
 			'metrics',

frontend/src/container/RolesSettings/permissions.config.ts

@@ -2,7 +2,6 @@ import {
 	Bot,
 	ChartLine,
 	DraftingCompass,
-	FileKey,
 	Gauge,
 	Key,
 	Logs,
@@ -62,13 +61,6 @@ export const RESOURCE_PANELS: Record<AuthZResource, ResourcePanelConfig> = {
 			'Type service account ID, separate multiple with comma or space',
 		docsAnchor: 'service-account',
 	},
-	license: {
-		label: 'Licenses',
-		description: 'Licenses of the workspace, including the license key.',
-		icon: FileKey,
-		selectorPlaceholder: 'Type license ID, separate multiple with comma or space',
-		docsAnchor: 'license',
-	},
 	logs: {
 		label: 'Logs',
 		description: 'Log data collected across the workspace.',

frontend/src/hooks/queryBuilder/useGetCompositeQueryParam.ts

@@ -27,14 +27,6 @@ export const useGetCompositeQueryParam = (): Query | null => {
 				decodeURIComponent(compositeQuery.replace(/\+/g, ' ')),
 			);
 
-			// Add default values for optional fields if empty
-			if (parsedCompositeQuery?.builder) {
-				parsedCompositeQuery.builder.queryFormulas =
-					parsedCompositeQuery.builder.queryFormulas ?? [];
-				parsedCompositeQuery.builder.queryTraceOperator =
-					parsedCompositeQuery.builder.queryTraceOperator ?? [];
-			}
-
 			// Convert old format to new format for each query in builder.queryData
 			if (parsedCompositeQuery?.builder?.queryData) {
 				parsedCompositeQuery.builder.queryData =

frontend/src/hooks/queryBuilder/useGetSearchQueryParam.ts

@@ -0,0 +1,15 @@
+import { useMemo } from 'react';
+import { QuerySearchParamNames } from 'components/ExplorerCard/constants';
+import useUrlQuery from 'hooks/useUrlQuery';
+
+export const useGetSearchQueryParam = (
+	searchParams: QuerySearchParamNames,
+): string | null => {
+	const urlQuery = useUrlQuery();
+
+	return useMemo(() => {
+		const searchQuery = urlQuery.get(searchParams);
+
+		return searchQuery ? JSON.parse(searchQuery) : null;
+	}, [urlQuery, searchParams]);
+};

frontend/src/hooks/saveViews/__tests__/useGetSavedViewParams.test.ts

@@ -1,60 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import useUrlQuery from 'hooks/useUrlQuery';
-
-import { useGetSavedViewParams } from '../useGetSavedViewParams';
-
-jest.mock('hooks/useUrlQuery');
-
-const mockedUseUrlQuery = useUrlQuery as jest.Mock;
-
-const setSearch = (search: string): void => {
-	mockedUseUrlQuery.mockReturnValue(new URLSearchParams(search));
-};
-
-describe('useGetSavedViewParams', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-	});
-
-	it('returns empty strings when no params are present', () => {
-		setSearch('');
-
-		const { result } = renderHook(() => useGetSavedViewParams());
-
-		expect(result.current).toStrictEqual({ viewName: '', viewKey: '' });
-	});
-
-	it('parses JSON-stringified values', () => {
-		setSearch(
-			`viewName=${encodeURIComponent(
-				JSON.stringify('Hindsight'),
-			)}&viewKey=${encodeURIComponent(JSON.stringify('abc-123'))}`,
-		);
-
-		const { result } = renderHook(() => useGetSavedViewParams());
-
-		expect(result.current).toStrictEqual({
-			viewName: 'Hindsight',
-			viewKey: 'abc-123',
-		});
-	});
-
-	it('falls back to the raw string when a value is not valid JSON', () => {
-		setSearch('viewName=Hindsight&viewKey=some-uuid-value');
-
-		const { result } = renderHook(() => useGetSavedViewParams());
-
-		expect(result.current).toStrictEqual({
-			viewName: 'Hindsight',
-			viewKey: 'some-uuid-value',
-		});
-	});
-
-	it('does not throw and keeps the raw string for non-string JSON', () => {
-		setSearch('viewName=123');
-
-		const { result } = renderHook(() => useGetSavedViewParams());
-
-		expect(result.current).toStrictEqual({ viewName: '123', viewKey: '' });
-	});
-});

frontend/src/hooks/saveViews/useGetSavedViewParams.ts

@@ -1,33 +0,0 @@
-import { useMemo } from 'react';
-import { QueryParams } from 'constants/query';
-import useUrlQuery from 'hooks/useUrlQuery';
-
-interface SavedViewParams {
-	viewName: string;
-	viewKey: string;
-}
-
-const parseViewParam = (value: string | null): string => {
-	if (!value) {
-		return '';
-	}
-
-	try {
-		const parsed = JSON.parse(value);
-		return typeof parsed === 'string' ? parsed : value;
-	} catch {
-		return value;
-	}
-};
-
-export const useGetSavedViewParams = (): SavedViewParams => {
-	const urlQuery = useUrlQuery();
-
-	return useMemo(
-		() => ({
-			viewName: parseViewParam(urlQuery.get(QueryParams.viewName)),
-			viewKey: parseViewParam(urlQuery.get(QueryParams.viewKey)),
-		}),
-		[urlQuery],
-	);
-};

frontend/src/hooks/useActiveLicense/useActiveLicense.tsx

@@ -1,29 +0,0 @@
-import { useQuery, UseQueryResult } from 'react-query';
-import {
-	getActiveLicense,
-	getGetActiveLicenseQueryKey,
-} from 'api/generated/services/licenses';
-import APIError from 'types/api/error';
-import { LicenseResModel } from 'types/api/licensesV3/getActive';
-import { toAPIError } from 'utils/errorUtils';
-
-import { toLicenseResModel } from './utils';
-
-const useActiveLicense = (
-	isLoggedIn: boolean,
-): UseQueryResult<LicenseResModel, APIError> =>
-	useQuery({
-		queryFn: async (): Promise<LicenseResModel> => {
-			try {
-				const response = await getActiveLicense();
-				return toLicenseResModel(response.data);
-			} catch (error) {
-				throw toAPIError(error as Parameters<typeof toAPIError>[0]);
-			}
-		},
-		queryKey: getGetActiveLicenseQueryKey(),
-		enabled: !!isLoggedIn,
-		retry: false,
-	});
-
-export default useActiveLicense;

frontend/src/hooks/useActiveLicense/utils.ts

@@ -1,37 +0,0 @@
-import { LicensetypesGettableActiveLicenseDTO } from 'api/generated/services/sigNoz.schemas';
-import {
-	LicenseEvent,
-	LicensePlatform,
-	LicenseResModel,
-	LicenseState,
-	LicenseStatus,
-} from 'types/api/licensesV3/getActive';
-
-export const toLicenseResModel = (
-	dto: LicensetypesGettableActiveLicenseDTO,
-): LicenseResModel => ({
-	id: dto.id,
-	status: dto.status as LicenseStatus,
-	state: dto.state as LicenseState,
-	platform: dto.platform as LicensePlatform,
-	plan: {
-		id: dto.plan.id,
-		name: dto.plan.name,
-		description: dto.plan.description,
-		isActive: dto.plan.isActive,
-		createdAt: dto.plan.createdAt,
-		updatedAt: dto.plan.updatedAt,
-	},
-	eventQueue: {
-		event: dto.eventQueue.event as LicenseEvent,
-		status: dto.eventQueue.status,
-		scheduledAt: dto.eventQueue.scheduledAt,
-		createdAt: dto.eventQueue.createdAt,
-		updatedAt: dto.eventQueue.updatedAt,
-	},
-	freeUntil: dto.freeUntil,
-	createdAt: dto.createdAt,
-	updatedAt: dto.updatedAt,
-	validFrom: dto.validFrom,
-	validUntil: dto.validUntil,
-});

frontend/src/hooks/useActiveLicenseKey/useActiveLicenseKey.tsx

@@ -1,35 +0,0 @@
-import { useMemo } from 'react';
-import { useGetLicense } from 'api/generated/services/licenses';
-import { buildLicenseReadPermission } from 'lib/authz/hooks/useAuthZ/permissions/license.permissions';
-import { useAuthZ } from 'lib/authz/hooks/useAuthZ/useAuthZ';
-import { useAppContext } from 'providers/App/App';
-
-interface UseActiveLicenseKey {
-	licenseKey: string | undefined;
-	isLoading: boolean;
-}
-
-const useActiveLicenseKey = (): UseActiveLicenseKey => {
-	const { activeLicense } = useAppContext();
-
-	const permissions = useMemo(
-		() => (activeLicense ? [buildLicenseReadPermission(activeLicense.id)] : []),
-		[activeLicense],
-	);
-	const { allowed, isLoading: isAuthZLoading } = useAuthZ(permissions, {
-		enabled: !!activeLicense,
-	});
-
-	const { data, isLoading: isLicenseLoading } = useGetLicense(
-		{ id: activeLicense?.id ?? '' },
-		{ query: { enabled: !!activeLicense && allowed } },
-	);
-
-	return {
-		licenseKey: data?.data.key,
-		isLoading:
-			!!activeLicense && (isAuthZLoading || (allowed && isLicenseLoading)),
-	};
-};
-
-export default useActiveLicenseKey;

frontend/src/hooks/useActiveLicenseV3/useActiveLicenseV3.tsx

@@ -0,0 +1,18 @@
+import { useQuery, UseQueryResult } from 'react-query';
+import getActive from 'api/v3/licenses/active/get';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
+import { SuccessResponseV2 } from 'types/api';
+import APIError from 'types/api/error';
+import { LicenseResModel } from 'types/api/licensesV3/getActive';
+
+const useActiveLicenseV3 = (isLoggedIn: boolean): UseLicense =>
+	useQuery({
+		queryFn: getActive,
+		queryKey: [REACT_QUERY_KEY.GET_ACTIVE_LICENSE_V3],
+		enabled: !!isLoggedIn,
+		retry: false,
+	});
+
+type UseLicense = UseQueryResult<SuccessResponseV2<LicenseResModel>, APIError>;
+
+export default useActiveLicenseV3;

frontend/src/hooks/useHandleExplorerTabChange.ts

@@ -6,7 +6,7 @@ import { SIGNOZ_VALUE } from 'container/QueryBuilder/filters/OrderByFilter/const
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource } from 'types/common/queryBuilder';
 
-import { useGetSavedViewParams } from './saveViews/useGetSavedViewParams';
+import { useGetSearchQueryParam } from './queryBuilder/useGetSearchQueryParam';
 import { useQueryBuilder } from './queryBuilder/useQueryBuilder';
 
 export interface ICurrentQueryData {
@@ -31,7 +31,9 @@ export const useHandleExplorerTabChange = (): {
 		updateQueriesData,
 	} = useQueryBuilder();
 
-	const { viewName, viewKey } = useGetSavedViewParams();
+	const viewName = useGetSearchQueryParam(QueryParams.viewName) || '';
+
+	const viewKey = useGetSearchQueryParam(QueryParams.viewKey) || '';
 
 	const getUpdateQuery = useCallback(
 		(newPanelType: PANEL_TYPES): Query => {

frontend/src/lib/authz/hooks/useAuthZ/permissions.type.ts

@@ -8,19 +8,6 @@ export default {
 				type: 'metaresource',
 				allowedVerbs: ['create', 'delete', 'list', 'read', 'update'],
 			},
-			{
-				kind: 'license',
-				type: 'metaresource',
-				allowedVerbs: [
-					'attach',
-					'create',
-					'delete',
-					'detach',
-					'list',
-					'read',
-					'update',
-				],
-			},
 			{
 				kind: 'role',
 				type: 'role',

frontend/src/lib/authz/hooks/useAuthZ/permissions/license.permissions.ts

@@ -1,6 +0,0 @@
-import { buildPermission } from '../utils';
-import type { BrandedPermission } from '../types';
-
-// Resource-level — require a specific license id
-export const buildLicenseReadPermission = (id: string): BrandedPermission =>
-	buildPermission('read', `license:${id}`);

frontend/src/lib/authz/utils/authz-test-utils.ts

@@ -127,30 +127,30 @@ export function buildLicense(
 	overrides?: Partial<LicenseResModel>,
 ): LicenseResModel {
 	return {
-		id: 'test-license-id',
+		key: 'test-key',
 		status: LicenseStatus.VALID,
 		state: LicenseState.ACTIVATED,
 		platform: LicensePlatform.CLOUD,
-		eventQueue: {
-			createdAt: '0',
+		event_queue: {
+			created_at: '0',
 			event: LicenseEvent.NO_EVENT,
-			scheduledAt: '0',
+			scheduled_at: '0',
 			status: '',
-			updatedAt: '0',
+			updated_at: '0',
 		},
 		plan: {
-			id: '0',
-			createdAt: '0',
+			created_at: '0',
 			description: '',
-			isActive: true,
+			is_active: true,
 			name: '',
-			updatedAt: '0',
+			updated_at: '0',
 		},
-		freeUntil: '0',
-		updatedAt: '0',
-		validFrom: 0,
-		validUntil: 0,
-		createdAt: '0',
+		plan_id: '0',
+		free_until: '0',
+		updated_at: '0',
+		valid_from: 0,
+		valid_until: 0,
+		created_at: '0',
 		...overrides,
 	};
 }

frontend/src/providers/App/App.tsx

@@ -22,7 +22,7 @@ import listUserPreferences from 'api/v1/user/preferences/list';
 import getUserVersion from 'api/v1/version/get';
 import { LOCALSTORAGE } from 'constants/localStorage';
 import dayjs from 'dayjs';
-import useActiveLicense from 'hooks/useActiveLicense/useActiveLicense';
+import useActiveLicenseV3 from 'hooks/useActiveLicenseV3/useActiveLicenseV3';
 import {
 	IsAdminPermission,
 	IsEditorPermission,
@@ -210,34 +210,35 @@ export function AppProvider({ children }: PropsWithChildren): JSX.Element {
 		}
 	}, [userData, isFetchingUserData]);
 
-	// fetcher for the active license
+	// fetcher for licenses v3
 	const {
 		data: activeLicenseData,
 		isFetching: isFetchingActiveLicense,
 		error: activeLicenseFetchError,
 		refetch: activeLicenseRefetch,
-	} = useActiveLicense(isLoggedIn);
+	} = useActiveLicenseV3(isLoggedIn);
 	useEffect(() => {
-		if (!isFetchingActiveLicense && activeLicenseData) {
-			setActiveLicense(activeLicenseData);
+		if (!isFetchingActiveLicense && activeLicenseData && activeLicenseData.data) {
+			setActiveLicense(activeLicenseData.data);
 
-			const freeUntilUnix = dayjs(activeLicenseData.freeUntil).unix();
-			const scheduledAtUnix = dayjs(
-				activeLicenseData.eventQueue.scheduledAt,
-			).unix();
+			const isOnTrial = dayjs(
+				activeLicenseData.data.free_until || Date.now(),
+			).isAfter(dayjs());
 
 			const trialInfo: TrialInfo = {
-				trialStart: activeLicenseData.validFrom,
-				trialEnd: freeUntilUnix > 0 ? freeUntilUnix : dayjs().unix(),
-				onTrial: dayjs(activeLicenseData.freeUntil).isAfter(dayjs()),
+				trialStart: activeLicenseData.data.valid_from,
+				trialEnd: dayjs(activeLicenseData.data.free_until || Date.now()).unix(),
+				onTrial: isOnTrial,
 				workSpaceBlock:
-					activeLicenseData.state === LicenseState.EVALUATION_EXPIRED &&
-					activeLicenseData.platform === LicensePlatform.CLOUD,
+					activeLicenseData.data.state === LicenseState.EVALUATION_EXPIRED &&
+					activeLicenseData.data.platform === LicensePlatform.CLOUD,
 				trialConvertedToSubscription:
-					activeLicenseData.state !== LicenseState.ISSUED &&
-					activeLicenseData.state !== LicenseState.EVALUATING &&
-					activeLicenseData.state !== LicenseState.EVALUATION_EXPIRED,
-				gracePeriodEnd: scheduledAtUnix > 0 ? scheduledAtUnix : dayjs().unix(),
+					activeLicenseData.data.state !== LicenseState.ISSUED &&
+					activeLicenseData.data.state !== LicenseState.EVALUATING &&
+					activeLicenseData.data.state !== LicenseState.EVALUATION_EXPIRED,
+				gracePeriodEnd: dayjs(
+					activeLicenseData.data.event_queue.scheduled_at || Date.now(),
+				).unix(),
 			};
 
 			setTrialInfo(trialInfo);

frontend/src/providers/QueryBuilder.tsx

@@ -163,23 +163,20 @@ export function QueryBuilderProvider({
 	const prepareQueryBuilderData = useCallback(
 		(query: Query): Query => {
 			const builder: QueryBuilderData = {
-				queryData:
-					query.builder.queryData?.map((item) => ({
-						...initialQueryBuilderFormValuesMap[
-							initialDataSource || DataSource.METRICS
-						],
-						...item,
-					})) ?? [],
-				queryFormulas:
-					query.builder.queryFormulas?.map((item) => ({
-						...initialFormulaBuilderFormValues,
-						...item,
-					})) ?? [],
-				queryTraceOperator:
-					query.builder.queryTraceOperator?.map((item) => ({
-						...initialQueryBuilderFormTraceOperatorValues,
-						...item,
-					})) ?? [],
+				queryData: query.builder.queryData?.map((item) => ({
+					...initialQueryBuilderFormValuesMap[
+						initialDataSource || DataSource.METRICS
+					],
+					...item,
+				})),
+				queryFormulas: query.builder.queryFormulas?.map((item) => ({
+					...initialFormulaBuilderFormValues,
+					...item,
+				})),
+				queryTraceOperator: query.builder.queryTraceOperator?.map((item) => ({
+					...initialQueryBuilderFormTraceOperatorValues,
+					...item,
+				})),
 			};
 
 			const setupedQueryData = builder.queryData.map((item) => {
@@ -212,17 +209,15 @@ export function QueryBuilderProvider({
 				return currentElement;
 			});
 
-			const promql: IPromQLQuery[] =
-				query.promql?.map((item) => ({
-					...initialQueryPromQLData,
-					...item,
-				})) ?? [];
+			const promql: IPromQLQuery[] = query.promql.map((item) => ({
+				...initialQueryPromQLData,
+				...item,
+			}));
 
-			const clickHouse: IClickHouseQuery[] =
-				query.clickhouse_sql?.map((item) => ({
-					...initialClickHouseData,
-					...item,
-				})) ?? [];
+			const clickHouse: IClickHouseQuery[] = query.clickhouse_sql.map((item) => ({
+				...initialClickHouseData,
+				...item,
+			}));
 
 			const newQueryState: QueryState = {
 				clickhouse_sql: clickHouse,

frontend/src/schemas/generated/transactionGroups.schema.json

@@ -66,7 +66,6 @@
         "factor-api-key",
         "license",
         "subscription",
-        "deployment-host",
         "logs",
         "traces",
         "metrics",

frontend/src/tests/test-utils.tsx

@@ -158,30 +158,30 @@ export function getAppContextMock(
 ): IAppContext {
 	return {
 		activeLicense: {
-			id: 'test-license-id',
-			eventQueue: {
-				createdAt: '0',
+			key: 'test-key',
+			event_queue: {
+				created_at: '0',
 				event: LicenseEvent.NO_EVENT,
-				scheduledAt: '0',
+				scheduled_at: '0',
 				status: '',
-				updatedAt: '0',
+				updated_at: '0',
 			},
 			state: LicenseState.ACTIVATED,
 			status: LicenseStatus.VALID,
 			platform: LicensePlatform.CLOUD,
-			createdAt: '0',
+			created_at: '0',
 			plan: {
-				id: '0',
-				createdAt: '0',
+				created_at: '0',
 				description: '',
-				isActive: true,
+				is_active: true,
 				name: '',
-				updatedAt: '0',
+				updated_at: '0',
 			},
-			freeUntil: '0',
-			updatedAt: '0',
-			validFrom: 0,
-			validUntil: 0,
+			plan_id: '0',
+			free_until: '0',
+			updated_at: '0',
+			valid_from: 0,
+			valid_until: 0,
 		},
 		trialInfo: {
 			trialStart: -1,

frontend/src/types/api/licenses/apply.ts

@@ -0,0 +1,10 @@
+import { License } from './def';
+
+export interface Props {
+	key: string;
+}
+
+export interface PayloadProps {
+	status: string;
+	data: License;
+}

frontend/src/types/api/licenses/def.ts

@@ -0,0 +1,8 @@
+export interface License {
+	key: string;
+	ValidFrom: Date;
+	ValidUntil: Date;
+	planKey: string;
+	status: string;
+	isCurrent: boolean;
+}

frontend/src/types/api/licensesV3/getActive.ts

@@ -1,59 +1,57 @@
 export enum LicenseEvent {
 	NO_EVENT = '',
-	DEFAULT = 'default',
+	DEFAULT = 'DEFAULT',
 }
 
 export enum LicenseStatus {
-	SUSPENDED = 'suspended',
-	VALID = 'valid',
-	INVALID = 'invalid',
+	SUSPENDED = 'SUSPENDED',
+	VALID = 'VALID',
+	INVALID = 'INVALID',
 }
 
 export enum LicenseState {
-	DEFAULTED = 'defaulted',
-	ACTIVATED = 'activated',
-	EXPIRED = 'expired',
-	ISSUED = 'issued',
-	EVALUATING = 'evaluating',
-	EVALUATION_EXPIRED = 'evaluation_expired',
-	TERMINATED = 'terminated',
-	CANCELLED = 'cancelled',
+	DEFAULTED = 'DEFAULTED',
+	ACTIVATED = 'ACTIVATED',
+	EXPIRED = 'EXPIRED',
+	ISSUED = 'ISSUED',
+	EVALUATING = 'EVALUATING',
+	EVALUATION_EXPIRED = 'EVALUATION_EXPIRED',
+	TERMINATED = 'TERMINATED',
+	CANCELLED = 'CANCELLED',
 }
 
 export enum LicensePlatform {
-	SELF_HOSTED = 'self_hosted',
-	CLOUD = 'cloud',
+	SELF_HOSTED = 'SELF_HOSTED',
+	CLOUD = 'CLOUD',
 }
 
-export type LicensePlanResModel = {
-	id: string;
-	name: string;
-	description: string;
-	isActive: boolean;
-	createdAt: string;
-	updatedAt: string;
-};
-
 export type LicenseEventQueueResModel = {
 	event: LicenseEvent;
 	status: string;
-	scheduledAt: string;
-	createdAt: string;
-	updatedAt: string;
+	scheduled_at: string;
+	created_at: string;
+	updated_at: string;
 };
 
 export type LicenseResModel = {
-	id: string;
+	key: string;
 	status: LicenseStatus;
 	state: LicenseState;
+	event_queue: LicenseEventQueueResModel;
 	platform: LicensePlatform;
-	plan: LicensePlanResModel;
-	eventQueue: LicenseEventQueueResModel;
-	freeUntil: string;
-	createdAt: string;
-	updatedAt: string;
-	validFrom: number;
-	validUntil: number;
+	created_at: string;
+	plan: {
+		created_at: string;
+		description: string;
+		is_active: boolean;
+		name: string;
+		updated_at: string;
+	};
+	plan_id: string;
+	free_until: string;
+	updated_at: string;
+	valid_from: number;
+	valid_until: number;
 };
 
 // Duplicate of old licenses API response, need to improve this later
@@ -65,3 +63,8 @@ export type TrialInfo = {
 	trialConvertedToSubscription: boolean;
 	gracePeriodEnd: number;
 };
+
+export interface PayloadProps {
+	data: LicenseEventQueueResModel;
+	status: string;
+}

pkg/apiserver/signozapiserver/flagger.go

@@ -4,12 +4,13 @@ import (
 	"net/http"
 
 	"github.com/SigNoz/signoz/pkg/http/handler"
+	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/featuretypes"
 	"github.com/gorilla/mux"
 )
 
 func (provider *provider) addFlaggerRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v2/features", handler.New(provider.authzMiddleware.OpenAccess(provider.flaggerHandler.GetFeatures), handler.OpenAPIDef{
+	if err := router.Handle("/api/v2/features", handler.New(provider.authzMiddleware.ViewAccess(provider.flaggerHandler.GetFeatures), handler.OpenAPIDef{
 		ID:                  "GetFeatures",
 		Tags:                []string{"features"},
 		Summary:             "Get features",
@@ -21,7 +22,7 @@ func (provider *provider) addFlaggerRoutes(router *mux.Router) error {
 		SuccessStatusCode:   http.StatusOK,
 		ErrorStatusCodes:    []int{},
 		Deprecated:          false,
-		SecuritySchemes:     newScopedSecuritySchemes(nil),
+		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
 	})).Methods(http.MethodGet).GetError(); err != nil {
 		return err
 	}

pkg/apiserver/signozapiserver/licensing.go

@@ -1,165 +0,0 @@
-package signozapiserver
-
-import (
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/http/handler"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/coretypes"
-	"github.com/SigNoz/signoz/pkg/types/licensetypes"
-	"github.com/gorilla/mux"
-)
-
-func (provider *provider) addLicensingRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v4/licenses", handler.New(
-		provider.authzMiddleware.CheckResources(provider.licensingHandler.Create, authtypes.SigNozAdminRoleName),
-		handler.OpenAPIDef{
-			ID:                  "ActivateLicense",
-			Tags:                []string{"licenses"},
-			Summary:             "Activate a license.",
-			Description:         "This endpoint validates the license key with the upstream server and activates the license for the organization.",
-			Request:             new(licensetypes.PostableLicense),
-			RequestContentType:  "application/json",
-			Response:            nil,
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusAccepted,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusForbidden, http.StatusNotFound, http.StatusConflict},
-			Deprecated:          false,
-			SecuritySchemes:     newScopedSecuritySchemes([]string{coretypes.ResourceMetaResourceLicense.Scope(coretypes.VerbCreate)}),
-		},
-		handler.WithResourceDefs(handler.BasicResourceDef{
-			Resource: coretypes.ResourceMetaResourceLicense,
-			Verb:     coretypes.VerbCreate,
-			Category: coretypes.ActionCategoryConfigurationChange,
-			Selector: coretypes.WildcardSelector,
-		}),
-	)).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v4/licenses", handler.New(
-		provider.authzMiddleware.CheckResources(provider.licensingHandler.List, authtypes.SigNozAdminRoleName),
-		handler.OpenAPIDef{
-			ID:                  "ListLicenses",
-			Tags:                []string{"licenses"},
-			Summary:             "List licenses.",
-			Description:         "This endpoint lists all the licenses of the organization.",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            make([]*licensetypes.GettableLicense, 0),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusForbidden},
-			Deprecated:          false,
-			SecuritySchemes:     newScopedSecuritySchemes([]string{coretypes.ResourceMetaResourceLicense.Scope(coretypes.VerbList)}),
-		},
-		handler.WithResourceDefs(handler.BasicResourceDef{
-			Resource: coretypes.ResourceMetaResourceLicense,
-			Verb:     coretypes.VerbList,
-			Category: coretypes.ActionCategoryDataAccess,
-			Selector: coretypes.WildcardSelector,
-		}),
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v4/licenses/active", handler.New(provider.authzMiddleware.OpenAccess(provider.licensingHandler.GetActive), handler.OpenAPIDef{
-		ID:                  "GetActiveLicense",
-		Tags:                []string{"licenses"},
-		Summary:             "Get the active license.",
-		Description:         "This endpoint gets the active license of the organization.",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            new(licensetypes.GettableActiveLicense),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusNotFound, http.StatusNotImplemented},
-		Deprecated:          false,
-		SecuritySchemes:     newScopedSecuritySchemes(nil),
-	})).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v4/licenses/{id}", handler.New(
-		provider.authzMiddleware.CheckResources(provider.licensingHandler.Get, authtypes.SigNozAdminRoleName),
-		handler.OpenAPIDef{
-			ID:                  "GetLicense",
-			Tags:                []string{"licenses"},
-			Summary:             "Get a license.",
-			Description:         "This endpoint gets the license by id.",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            new(licensetypes.GettableLicenseWithKey),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusForbidden, http.StatusNotFound},
-			Deprecated:          false,
-			SecuritySchemes:     newScopedSecuritySchemes([]string{coretypes.ResourceMetaResourceLicense.Scope(coretypes.VerbRead)}),
-		},
-		handler.WithResourceDefs(handler.BasicResourceDef{
-			Resource: coretypes.ResourceMetaResourceLicense,
-			Verb:     coretypes.VerbRead,
-			Category: coretypes.ActionCategoryDataAccess,
-			ID:       coretypes.PathParam("id"),
-			Selector: coretypes.IDSelector,
-		}),
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v4/licenses/{id}", handler.New(
-		provider.authzMiddleware.CheckResources(provider.licensingHandler.Refresh, authtypes.SigNozAdminRoleName),
-		handler.OpenAPIDef{
-			ID:                  "RefreshLicense",
-			Tags:                []string{"licenses"},
-			Summary:             "Refresh a license.",
-			Description:         "This endpoint refreshes the active license of the organization from the upstream server.",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            nil,
-			ResponseContentType: "",
-			SuccessStatusCode:   http.StatusNoContent,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusForbidden, http.StatusNotFound},
-			Deprecated:          false,
-			SecuritySchemes:     newScopedSecuritySchemes([]string{coretypes.ResourceMetaResourceLicense.Scope(coretypes.VerbUpdate)}),
-		},
-		handler.WithResourceDefs(handler.BasicResourceDef{
-			Resource: coretypes.ResourceMetaResourceLicense,
-			Verb:     coretypes.VerbUpdate,
-			Category: coretypes.ActionCategoryConfigurationChange,
-			ID:       coretypes.PathParam("id"),
-			Selector: coretypes.IDSelector,
-		}),
-	)).Methods(http.MethodPut).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v4/licenses/{id}", handler.New(
-		provider.authzMiddleware.CheckResources(provider.licensingHandler.Delete, authtypes.SigNozAdminRoleName),
-		handler.OpenAPIDef{
-			ID:                  "DeleteLicense",
-			Tags:                []string{"licenses"},
-			Summary:             "Delete a license.",
-			Description:         "This endpoint deletes the license by id. Licenses managed by SigNoz Cloud cannot be deleted.",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            nil,
-			ResponseContentType: "",
-			SuccessStatusCode:   http.StatusNoContent,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusForbidden, http.StatusNotFound},
-			Deprecated:          false,
-			SecuritySchemes:     newScopedSecuritySchemes([]string{coretypes.ResourceMetaResourceLicense.Scope(coretypes.VerbDelete)}),
-		},
-		handler.WithResourceDefs(handler.BasicResourceDef{
-			Resource: coretypes.ResourceMetaResourceLicense,
-			Verb:     coretypes.VerbDelete,
-			Category: coretypes.ActionCategoryConfigurationChange,
-			ID:       coretypes.PathParam("id"),
-			Selector: coretypes.IDSelector,
-		}),
-	)).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
-	return nil
-}

pkg/apiserver/signozapiserver/provider.go

@@ -12,7 +12,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/http/handler"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
-	"github.com/SigNoz/signoz/pkg/licensing"
 	"github.com/SigNoz/signoz/pkg/modules/aiobservability"
 	"github.com/SigNoz/signoz/pkg/modules/authdomain"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
@@ -68,7 +67,6 @@ type provider struct {
 	authzHandler               authz.Handler
 	rawDataExportHandler       rawdataexport.Handler
 	zeusHandler                zeus.Handler
-	licensingHandler           licensing.Handler
 	querierHandler             querier.Handler
 	serviceAccountHandler      serviceaccount.Handler
 	serviceAccountGetter       serviceaccount.Getter
@@ -107,7 +105,6 @@ func NewFactory(
 	authzHandler authz.Handler,
 	rawDataExportHandler rawdataexport.Handler,
 	zeusHandler zeus.Handler,
-	licensingHandler licensing.Handler,
 	querierHandler querier.Handler,
 	serviceAccountHandler serviceaccount.Handler,
 	serviceAccountGetter serviceaccount.Getter,
@@ -149,7 +146,6 @@ func NewFactory(
 			authzHandler,
 			rawDataExportHandler,
 			zeusHandler,
-			licensingHandler,
 			querierHandler,
 			serviceAccountHandler,
 			serviceAccountGetter,
@@ -193,7 +189,6 @@ func newProvider(
 	authzHandler authz.Handler,
 	rawDataExportHandler rawdataexport.Handler,
 	zeusHandler zeus.Handler,
-	licensingHandler licensing.Handler,
 	querierHandler querier.Handler,
 	serviceAccountHandler serviceaccount.Handler,
 	serviceAccountGetter serviceaccount.Getter,
@@ -236,7 +231,6 @@ func newProvider(
 		authzHandler:               authzHandler,
 		rawDataExportHandler:       rawDataExportHandler,
 		zeusHandler:                zeusHandler,
-		licensingHandler:           licensingHandler,
 		querierHandler:             querierHandler,
 		serviceAccountHandler:      serviceAccountHandler,
 		serviceAccountGetter:       serviceAccountGetter,
@@ -338,10 +332,6 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
-	if err := provider.addLicensingRoutes(router); err != nil {
-		return err
-	}
-
 	if err := provider.addZeusRoutes(router); err != nil {
 		return err
 	}

pkg/apiserver/signozapiserver/zeus.go

@@ -5,8 +5,6 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/http/handler"
 	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/coretypes"
 	"github.com/SigNoz/signoz/pkg/types/zeustypes"
 	"github.com/gorilla/mux"
 )
@@ -29,7 +27,7 @@ func (provider *provider) addZeusRoutes(router *mux.Router) error {
 		return err
 	}
 
-	if err := router.Handle("/api/v2/zeus/hosts", handler.New(provider.authzMiddleware.CheckResources(provider.zeusHandler.GetHosts, authtypes.SigNozAdminRoleName, authtypes.SigNozEditorRoleName, authtypes.SigNozViewerRoleName), handler.OpenAPIDef{
+	if err := router.Handle("/api/v2/zeus/hosts", handler.New(provider.authzMiddleware.ViewAccess(provider.zeusHandler.GetHosts), handler.OpenAPIDef{
 		ID:                  "GetHosts",
 		Tags:                []string{"zeus"},
 		Summary:             "Get host info from Zeus.",
@@ -41,17 +39,12 @@ func (provider *provider) addZeusRoutes(router *mux.Router) error {
 		SuccessStatusCode:   http.StatusOK,
 		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusForbidden, http.StatusNotFound},
 		Deprecated:          false,
-		SecuritySchemes:     newScopedSecuritySchemes([]string{coretypes.ResourceMetaResourceDeploymentHost.Scope(coretypes.VerbList)}),
-	}, handler.WithResourceDefs(handler.BasicResourceDef{
-		Resource: coretypes.ResourceMetaResourceDeploymentHost,
-		Verb:     coretypes.VerbList,
-		Category: coretypes.ActionCategoryDataAccess,
-		Selector: coretypes.WildcardSelector,
-	}))).Methods(http.MethodGet).GetError(); err != nil {
+		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+	})).Methods(http.MethodGet).GetError(); err != nil {
 		return err
 	}
 
-	if err := router.Handle("/api/v2/zeus/hosts", handler.New(provider.authzMiddleware.CheckResources(provider.zeusHandler.PutHost, authtypes.SigNozAdminRoleName), handler.OpenAPIDef{
+	if err := router.Handle("/api/v2/zeus/hosts", handler.New(provider.authzMiddleware.AdminAccess(provider.zeusHandler.PutHost), handler.OpenAPIDef{
 		ID:                  "PutHost",
 		Tags:                []string{"zeus"},
 		Summary:             "Put host in Zeus for a deployment.",
@@ -63,14 +56,8 @@ func (provider *provider) addZeusRoutes(router *mux.Router) error {
 		SuccessStatusCode:   http.StatusNoContent,
 		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusForbidden, http.StatusNotFound, http.StatusConflict},
 		Deprecated:          false,
-		SecuritySchemes:     newScopedSecuritySchemes([]string{coretypes.ResourceMetaResourceDeploymentHost.Scope(coretypes.VerbUpdate)}),
-	}, handler.WithResourceDefs(handler.BasicResourceDef{
-		Resource: coretypes.ResourceMetaResourceDeploymentHost,
-		Verb:     coretypes.VerbUpdate,
-		Category: coretypes.ActionCategoryConfigurationChange,
-		ID:       coretypes.BodyJSONPath("name"),
-		Selector: coretypes.WildcardSelector,
-	}))).Methods(http.MethodPut).GetError(); err != nil {
+		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
+	})).Methods(http.MethodPut).GetError(); err != nil {
 		return err
 	}
 

pkg/licensing/handler.go

@@ -1,169 +0,0 @@
-package licensing
-
-import (
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/http/binding"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/licensetypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/gorilla/mux"
-)
-
-type handler struct {
-	licensing Licensing
-}
-
-func NewHandler(licensing Licensing) Handler {
-	return &handler{licensing: licensing}
-}
-
-func (handler *handler) Create(rw http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := new(licensetypes.PostableLicense)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	err = handler.licensing.Activate(ctx, valuer.MustNewUUID(claims.OrgID), req.Key)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusAccepted, nil)
-}
-
-func (handler *handler) List(rw http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	licenses, err := handler.licensing.List(ctx, valuer.MustNewUUID(claims.OrgID))
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	gettableLicenses := make([]*licensetypes.GettableLicense, 0, len(licenses))
-	for _, license := range licenses {
-		gettableLicenses = append(gettableLicenses, licensetypes.NewGettableLicense(license))
-	}
-
-	render.Success(rw, http.StatusOK, gettableLicenses)
-}
-
-func (handler *handler) Get(rw http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	licenseID, err := valuer.NewUUID(mux.Vars(r)["id"])
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	license, err := handler.licensing.Get(ctx, valuer.MustNewUUID(claims.OrgID), licenseID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, licensetypes.NewGettableLicenseWithKey(license))
-}
-
-func (handler *handler) Refresh(rw http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	licenseID, err := valuer.NewUUID(mux.Vars(r)["id"])
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-
-	activeLicense, err := handler.licensing.GetActive(ctx, orgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if activeLicense.ID != licenseID {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "only the active license %s can be refreshed", activeLicense.ID.StringValue()))
-		return
-	}
-
-	if err := handler.licensing.Refresh(ctx, orgID); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-func (handler *handler) Delete(rw http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	licenseID, err := valuer.NewUUID(mux.Vars(r)["id"])
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := handler.licensing.Delete(ctx, valuer.MustNewUUID(claims.OrgID), licenseID); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-func (handler *handler) GetActive(rw http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	license, err := handler.licensing.GetActive(ctx, valuer.MustNewUUID(claims.OrgID))
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, licensetypes.NewGettableActiveLicense(license))
-}

pkg/licensing/licensing.go

@@ -21,16 +21,10 @@ type Licensing interface {
 
 	// Validate validates the license with the upstream server
 	Validate(ctx context.Context) error
-	// Activate validates the key with the upstream server and enables the license
+	// Activate validates and enables the license
 	Activate(ctx context.Context, organizationID valuer.UUID, key string) error
 	// GetActive fetches the current active license in org
 	GetActive(ctx context.Context, organizationID valuer.UUID) (*licensetypes.License, error)
-	// Get fetches the license by id in org
-	Get(ctx context.Context, organizationID valuer.UUID, licenseID valuer.UUID) (*licensetypes.License, error)
-	// List fetches all the licenses in org
-	List(ctx context.Context, organizationID valuer.UUID) ([]*licensetypes.License, error)
-	// Delete deletes the license by id in org, cloud licenses cannot be deleted
-	Delete(ctx context.Context, organizationID valuer.UUID, licenseID valuer.UUID) error
 	// Refresh refreshes the license state from upstream server
 	Refresh(ctx context.Context, organizationID valuer.UUID) error
 	// Checkout creates a checkout session via upstream server and returns the redirection link
@@ -44,20 +38,10 @@ type Licensing interface {
 }
 
 type API interface {
+	Activate(http.ResponseWriter, *http.Request)
+	Refresh(http.ResponseWriter, *http.Request)
+	GetActive(http.ResponseWriter, *http.Request)
+
 	Checkout(http.ResponseWriter, *http.Request)
 	Portal(http.ResponseWriter, *http.Request)
 }
-
-type Handler interface {
-	Create(http.ResponseWriter, *http.Request)
-
-	List(http.ResponseWriter, *http.Request)
-
-	Get(http.ResponseWriter, *http.Request)
-
-	Refresh(http.ResponseWriter, *http.Request)
-
-	Delete(http.ResponseWriter, *http.Request)
-
-	GetActive(http.ResponseWriter, *http.Request)
-}

pkg/licensing/nooplicensing/api.go

@@ -14,6 +14,18 @@ func NewLicenseAPI() licensing.API {
 	return &noopLicensingAPI{}
 }
 
+func (api *noopLicensingAPI) Activate(rw http.ResponseWriter, r *http.Request) {
+	render.Error(rw, errors.New(errors.TypeUnsupported, licensing.ErrCodeUnsupported, "not implemented"))
+}
+
+func (api *noopLicensingAPI) GetActive(rw http.ResponseWriter, r *http.Request) {
+	render.Error(rw, errors.New(errors.TypeUnsupported, licensing.ErrCodeUnsupported, "not implemented"))
+}
+
+func (api *noopLicensingAPI) Refresh(rw http.ResponseWriter, r *http.Request) {
+	render.Error(rw, errors.New(errors.TypeUnsupported, licensing.ErrCodeUnsupported, "not implemented"))
+}
+
 func (api *noopLicensingAPI) Checkout(rw http.ResponseWriter, r *http.Request) {
 	render.Error(rw, errors.New(errors.TypeUnsupported, licensing.ErrCodeUnsupported, "not implemented"))
 }

pkg/licensing/nooplicensing/provider.go

@@ -39,18 +39,6 @@ func (provider *noopLicensing) Activate(ctx context.Context, organizationID valu
 	return errors.New(errors.TypeUnsupported, licensing.ErrCodeUnsupported, "fetching license is not supported")
 }
 
-func (provider *noopLicensing) Get(ctx context.Context, organizationID valuer.UUID, licenseID valuer.UUID) (*licensetypes.License, error) {
-	return nil, errors.New(errors.TypeUnsupported, licensing.ErrCodeUnsupported, "fetching license is not supported")
-}
-
-func (provider *noopLicensing) List(ctx context.Context, organizationID valuer.UUID) ([]*licensetypes.License, error) {
-	return nil, errors.New(errors.TypeUnsupported, licensing.ErrCodeUnsupported, "listing licenses is not supported")
-}
-
-func (provider *noopLicensing) Delete(ctx context.Context, organizationID valuer.UUID, licenseID valuer.UUID) error {
-	return errors.New(errors.TypeUnsupported, licensing.ErrCodeUnsupported, "deleting license is not supported")
-}
-
 func (provider *noopLicensing) Validate(ctx context.Context) error {
 	return errors.New(errors.TypeUnsupported, licensing.ErrCodeUnsupported, "validating license is not supported")
 }

pkg/prometheus/engine.go

@@ -2,7 +2,6 @@ package prometheus
 
 import (
 	"log/slog"
-	"time"
 
 	"github.com/prometheus/prometheus/promql"
 )
@@ -24,11 +23,5 @@ func NewEngine(logger *slog.Logger, cfg Config) *Engine {
 		Timeout:            cfg.Timeout,
 		ActiveQueryTracker: activeQueryTracker,
 		LookbackDelta:      cfg.LookbackDelta,
-		// The engine calls this for subqueries that do not set a step, such as
-		// `metric[5m:]`, and segfaults if it is nil. 1m matches the default
-		// global evaluation_interval that Prometheus wires here.
-		NoStepSubqueryIntervalFn: func(int64) int64 {
-			return time.Minute.Milliseconds()
-		},
 	})
 }

pkg/prometheus/engine_test.go

@@ -1,33 +0,0 @@
-package prometheus
-
-import (
-	"context"
-	"log/slog"
-	"testing"
-	"time"
-
-	"github.com/prometheus/prometheus/storage"
-	"github.com/stretchr/testify/require"
-)
-
-func TestNoStepSubqueryDoesNotPanic(t *testing.T) {
-	engine := NewEngine(slog.New(slog.DiscardHandler), Config{Timeout: time.Minute})
-	queryable := storage.QueryableFunc(func(int64, int64) (storage.Querier, error) {
-		return storage.NoopQuerier(), nil
-	})
-
-	qry, err := engine.NewRangeQuery(
-		context.Background(),
-		queryable,
-		nil,
-		"max_over_time(some_metric[5m:])",
-		time.Now().Add(-time.Hour),
-		time.Now(),
-		time.Minute,
-	)
-	require.NoError(t, err)
-	defer qry.Close()
-
-	res := qry.Exec(context.Background())
-	require.NoError(t, res.Err)
-}

pkg/querier/builder_query.go

@@ -82,12 +82,6 @@ func (q *builderQuery[T]) Fingerprint() string {
 		return ""
 	}
 
-	// AI trace aggregations qualify and rank traces on whole-window per-trace
-	// values, which do not decompose into cacheable time buckets.
-	if q.queryType == qbtypes.QueryTypeBuilderAI {
-		return ""
-	}
-
 	// Create a deterministic fingerprint for builder queries
 	// This needs to include all fields that affect the query results
 	parts := []string{q.queryType.StringValue()}

pkg/querier/builder_query_test.go

@@ -117,7 +117,8 @@ func TestBuilderQueryFingerprintQueryType(t *testing.T) {
 	}
 
 	assert.True(t, strings.HasPrefix(regular.Fingerprint(), qbtypes.QueryTypeBuilder.StringValue()+"&"))
-	assert.Empty(t, ai.Fingerprint())
+	assert.True(t, strings.HasPrefix(ai.Fingerprint(), qbtypes.QueryTypeBuilderAI.StringValue()+"&"))
+	assert.NotEqual(t, regular.Fingerprint(), ai.Fingerprint())
 }
 
 func TestMakeBucketsOrder(t *testing.T) {

pkg/querier/querier.go

@@ -470,7 +470,7 @@ func (q *querier) resolveMetricMetadata(ctx context.Context, orgID valuer.UUID,
 				continue
 			}
 			// Type is resolved now; validate aggregation compatibility against it.
-			if err := spec.Aggregations[i].ValidateForTypeAndTemporality(); err != nil {
+			if err := spec.Aggregations[i].ValidateForType(); err != nil {
 				return nil, nil, err
 			}
 			if reducedMetricsSet[spec.Aggregations[i].MetricName] {

pkg/query-service/app/http_handler.go

@@ -439,7 +439,7 @@ func (aH *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	router.HandleFunc("/api/v2/traces/fields", am.EditAccess(aH.updateTraceField)).Methods(http.MethodPost)
 
 	router.HandleFunc("/api/v1/version", am.OpenAccess(aH.getVersion)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/features", am.OpenAccess(aH.getFeatureFlags)).Methods(http.MethodGet)
+	router.HandleFunc("/api/v1/features", am.ViewAccess(aH.getFeatureFlags)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/health", am.OpenAccess(aH.getHealth)).Methods(http.MethodGet)
 
 	router.HandleFunc("/api/v1/listErrors", am.ViewAccess(aH.listErrors)).Methods(http.MethodPost)
@@ -457,6 +457,13 @@ func (aH *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 
 	router.HandleFunc("/api/v1/register", am.OpenAccess(aH.registerUser)).Methods(http.MethodPost)
 
+	router.HandleFunc("/api/v3/licenses", am.ViewAccess(func(rw http.ResponseWriter, req *http.Request) {
+		render.Success(rw, http.StatusOK, []any{})
+	})).Methods(http.MethodGet)
+	router.HandleFunc("/api/v3/licenses/active", am.ViewAccess(func(rw http.ResponseWriter, req *http.Request) {
+		aH.LicensingAPI.Activate(rw, req)
+	})).Methods(http.MethodGet)
+
 	router.HandleFunc("/api/v1/span_percentile", am.ViewAccess(aH.Signoz.Handlers.SpanPercentile.GetSpanPercentileDetails)).Methods(http.MethodPost)
 
 	// Query Filter Analyzer api used to extract metric names and grouping columns from a query
@@ -1490,7 +1497,7 @@ func (aH *APIHandler) getFeatureFlags(w http.ResponseWriter, r *http.Request) {
 
 	claims, err := authtypes.ClaimsFromContext(r.Context())
 	if err != nil {
-		aH.HandleError(w, err, http.StatusUnauthorized)
+		aH.HandleError(w, err, http.StatusInternalServerError)
 		return
 	}
 

pkg/querybuilder/key_resolution.go

@@ -107,8 +107,8 @@ func SynthesizeKeys(field *telemetrytypes.TelemetryFieldKey, value any) []*telem
 		fieldContext = telemetrytypes.FieldContextAttribute
 	}
 	fieldDataType := field.FieldDataType
-	// Resource and scope values are strings; pin the type so operand coercion applies.
-	if (fieldContext == telemetrytypes.FieldContextResource || fieldContext == telemetrytypes.FieldContextScope) &&
+	// Resource values are strings; pin the type so operand coercion applies.
+	if fieldContext == telemetrytypes.FieldContextResource &&
 		fieldDataType == telemetrytypes.FieldDataTypeUnspecified {
 		fieldDataType = telemetrytypes.FieldDataTypeString
 	}

pkg/querybuilder/query_to_keys.go

@@ -56,17 +56,6 @@ func QueryStringToKeysSelectors(query string) []*telemetrytypes.FieldKeySelector
 					FieldDataType: key.FieldDataType,
 				})
 			}
-
-			// todo(tushar): consider reverting changes done to this method in below PR to avoid scope specific checks
-			// https://github.com/SigNoz/signoz/issues/11374
-			if key.FieldContext == telemetrytypes.FieldContextScope {
-				keys = append(keys, &telemetrytypes.FieldKeySelector{
-					Name:          key.FieldContext.StringValue() + "." + key.Name,
-					Signal:        key.Signal,
-					FieldContext:  telemetrytypes.FieldContextUnspecified, // this allows 'scope.' prefix for keys with other context as well
-					FieldDataType: key.FieldDataType,
-				})
-			}
 		}
 	}
 

pkg/querybuilder/query_to_keys_test.go

@@ -72,44 +72,6 @@ func TestQueryToKeys(t *testing.T) {
 				},
 			},
 		},
-		{
-			query: `scope.version = '1.0.0'`,
-			expectedKeys: []telemetrytypes.FieldKeySelector{
-				{
-					Name:          "version",
-					Signal:        telemetrytypes.SignalUnspecified,
-					FieldContext:  telemetrytypes.FieldContextScope,
-					FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
-				},
-				{
-					Name:          "scope.version",
-					Signal:        telemetrytypes.SignalUnspecified,
-					FieldContext:  telemetrytypes.FieldContextUnspecified,
-					FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
-				},
-			},
-		},
-		{
-			// A scope attribute whose own name carries a `scope.` prefix. `scope.prefixed`
-			// normalizes to {prefixed, scope}; the second selector re-adds the prefix so the
-			// metadata fetch can target the attribute's exact key `scope.prefixed` rather than
-			// relying on the broad `%prefixed%` match.
-			query: `scope.prefixed = 'x'`,
-			expectedKeys: []telemetrytypes.FieldKeySelector{
-				{
-					Name:          "prefixed",
-					Signal:        telemetrytypes.SignalUnspecified,
-					FieldContext:  telemetrytypes.FieldContextScope,
-					FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
-				},
-				{
-					Name:          "scope.prefixed",
-					Signal:        telemetrytypes.SignalUnspecified,
-					FieldContext:  telemetrytypes.FieldContextUnspecified,
-					FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
-				},
-			},
-		},
 	}
 
 	for _, testCase := range testCases {

pkg/signoz/handler.go

@@ -77,7 +77,6 @@ type Handlers struct {
 	AIObservability         aiobservability.Handler
 	AuthzHandler            authz.Handler
 	ZeusHandler             zeus.Handler
-	LicensingHandler        licensing.Handler
 	QuerierHandler          querier.Handler
 	ServiceAccountHandler   serviceaccount.Handler
 	RegistryHandler         factory.Handler
@@ -96,7 +95,7 @@ func NewHandlers(
 	providerSettings factory.ProviderSettings,
 	analytics analytics.Analytics,
 	querierHandler querier.Handler,
-	licensingService licensing.Licensing,
+	licensing licensing.Licensing,
 	global global.Global,
 	flaggerService flagger.Flagger,
 	gatewayService gateway.Gateway,
@@ -126,8 +125,7 @@ func NewHandlers(
 		Fields:                  implfields.NewHandler(providerSettings, telemetryMetadataStore),
 		AIObservability:         implaiobservability.NewHandler(telemetryMetadataStore),
 		AuthzHandler:            signozauthzapi.NewHandler(authz),
-		ZeusHandler:             zeus.NewHandler(zeusService, licensingService),
-		LicensingHandler:        licensing.NewHandler(licensingService),
+		ZeusHandler:             zeus.NewHandler(zeusService, licensing),
 		QuerierHandler:          querierHandler,
 		ServiceAccountHandler:   implserviceaccount.NewHandler(modules.ServiceAccount, modules.ServiceAccountGetter),
 		RegistryHandler:         registryHandler,

pkg/signoz/openapi.go

@@ -17,7 +17,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/http/handler"
 	"github.com/SigNoz/signoz/pkg/instrumentation"
-	"github.com/SigNoz/signoz/pkg/licensing"
 	"github.com/SigNoz/signoz/pkg/modules/aiobservability"
 	"github.com/SigNoz/signoz/pkg/modules/authdomain"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
@@ -81,7 +80,6 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ authz.Handler }{},
 		struct{ rawdataexport.Handler }{},
 		struct{ zeus.Handler }{},
-		struct{ licensing.Handler }{},
 		struct{ querier.Handler }{},
 		struct{ serviceaccount.Handler }{},
 		struct{ serviceaccount.Getter }{},