Merge branch 'main' into issue_4501

cmd/community/server.go

@@ -46,6 +46,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/SigNoz/signoz/pkg/zeus"
@@ -103,8 +104,8 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 
 			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx), openfgaDataStore, authtypes.NewRegistry()), nil
 		},
-		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, _ querier.Querier, _ licensing.Licensing, tagModule tag.Module) dashboard.Module {
-			return impldashboard.NewModule(impldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, tagModule)
+		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, _ querier.Querier, _ licensing.Licensing, tagModule tag.Module, systemDashboardRegistry dashboardtypes.SystemDashboardRegistry) dashboard.Module {
+			return impldashboard.NewModule(impldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, tagModule, systemDashboardRegistry)
 		},
 		func(_ licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config] {
 			return noopgateway.NewProviderFactory()

cmd/enterprise/server.go

@@ -63,6 +63,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/types/cloudintegrationtypes"
+	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/SigNoz/signoz/pkg/zeus"
@@ -136,8 +137,8 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 			}
 			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx), openfgaDataStore, licensing, onBeforeRoleDelete, authtypes.NewRegistry()), nil
 		},
-		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing, tagModule tag.Module) dashboard.Module {
-			return impldashboard.NewModule(pkgimpldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, querier, licensing, tagModule)
+		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing, tagModule tag.Module, systemDashboardRegistry dashboardtypes.SystemDashboardRegistry) dashboard.Module {
+			return impldashboard.NewModule(pkgimpldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, querier, licensing, tagModule, systemDashboardRegistry)
 		},
 		func(licensing licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config] {
 			return httpgateway.NewProviderFactory(licensing)

docs/api/openapi.yml

@@ -2944,6 +2944,46 @@ components:
         publicDashboard:
           $ref: '#/components/schemas/DashboardtypesGettablePublicDasbhboard'
       type: object
+    DashboardtypesGettableSystemDashboard:
+      properties:
+        createdAt:
+          format: date-time
+          type: string
+        createdBy:
+          type: string
+        image:
+          type: string
+        locked:
+          type: boolean
+        name:
+          type: string
+        orgId:
+          type: string
+        schemaVersion:
+          type: string
+        source:
+          $ref: '#/components/schemas/DashboardtypesSource'
+        spec:
+          $ref: '#/components/schemas/DashboardtypesDashboardSpec'
+        tags:
+          items:
+            $ref: '#/components/schemas/TagtypesGettableTag'
+          nullable: true
+          type: array
+        updatedAt:
+          format: date-time
+          type: string
+        updatedBy:
+          type: string
+      required:
+      - orgId
+      - locked
+      - source
+      - schemaVersion
+      - name
+      - tags
+      - spec
+      type: object
     DashboardtypesHistogramBuckets:
       properties:
         bucketCount:
@@ -5642,171 +5682,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
-    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:
@@ -15524,6 +15399,73 @@ paths:
       summary: Migrate dashboard to v2
       tags:
       - dashboard
+  /api/v2/dashboards/system/{name}:
+    get:
+      deprecated: false
+      description: Returns a dashboard SigNoz ships and owns, addressed by its stable
+        definition name (e.g. `ai-o11y-overview`) rather than its id. System dashboards
+        are read-only and upgraded through releases. The dashboard's own `name` field
+        carries a reserved prefix that the path segment must not include.
+      operationId: GetSystemDashboard
+      parameters:
+      - in: path
+        name: name
+        required: true
+        schema:
+          type: string
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/DashboardtypesGettableSystemDashboard'
+                  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:
+        - dashboard:read
+      - tokenizer:
+        - dashboard:read
+      summary: Get system dashboard
+      tags:
+      - dashboard
   /api/v2/factor_password/forgot:
     post:
       deprecated: false
@@ -24365,347 +24307,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/orgs/me/license:
-    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/LicensetypesGettableLicense'
-                  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/modules/dashboard/impldashboard/module.go

@@ -32,9 +32,9 @@ type module struct {
 	tagModule          tag.Module
 }
 
-func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing, tagModule tag.Module) dashboard.Module {
+func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing, tagModule tag.Module, systemDashboardRegistry dashboardtypes.SystemDashboardRegistry) dashboard.Module {
 	scopedProviderSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/ee/modules/dashboard/impldashboard")
-	pkgDashboardModule := pkgimpldashboard.NewModule(store, settings, analytics, orgGetter, queryParser, tagModule)
+	pkgDashboardModule := pkgimpldashboard.NewModule(store, settings, analytics, orgGetter, queryParser, tagModule, systemDashboardRegistry)
 
 	return &module{
 		pkgDashboardModule: pkgDashboardModule,
@@ -361,6 +361,14 @@ func (module *module) LockUnlock(ctx context.Context, orgID valuer.UUID, id valu
 	return module.pkgDashboardModule.LockUnlock(ctx, orgID, id, updatedBy, isAdmin, lock)
 }
 
+func (module *module) ReconcileSystemDashboards(ctx context.Context, orgID valuer.UUID) error {
+	return module.pkgDashboardModule.ReconcileSystemDashboards(ctx, orgID)
+}
+
+func (module *module) GetSystemDashboard(ctx context.Context, orgID valuer.UUID, name string) (*dashboardtypes.DashboardV2, error) {
+	return module.pkgDashboardModule.GetSystemDashboard(ctx, orgID, name)
+}
+
 func (module *module) delete(ctx context.Context, orgID, id valuer.UUID) error {
 	return module.store.RunInTx(ctx, func(ctx context.Context) error {
 		if err := module.store.DeletePublic(ctx, id.String()); err != nil && !errors.Ast(err, errors.TypeNotFound) {

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

@@ -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/api/generated/services/dashboard/index.ts

@@ -46,6 +46,8 @@ import type {
 	GetPublicDashboardPathParameters,
 	GetPublicDashboardWidgetQueryRange200,
 	GetPublicDashboardWidgetQueryRangePathParameters,
+	GetSystemDashboard200,
+	GetSystemDashboardPathParameters,
 	ListDashboardViews200,
 	ListDashboardsForUserV2200,
 	ListDashboardsForUserV2Params,
@@ -1885,6 +1887,108 @@ export const useMigrateDashboardV2 = <
 > => {
 	return useMutation(getMigrateDashboardV2MutationOptions(options));
 };
+/**
+ * Returns a dashboard SigNoz ships and owns, addressed by its stable definition name (e.g. `ai-o11y-overview`) rather than its id. System dashboards are read-only and upgraded through releases. The dashboard's own `name` field carries a reserved prefix that the path segment must not include.
+ * @summary Get system dashboard
+ */
+export const getSystemDashboard = (
+	{ name }: GetSystemDashboardPathParameters,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<GetSystemDashboard200>({
+		url: `/api/v2/dashboards/system/${name}`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getGetSystemDashboardQueryKey = ({
+	name,
+}: GetSystemDashboardPathParameters) => {
+	return [`/api/v2/dashboards/system/${name}`] as const;
+};
+
+export const getGetSystemDashboardQueryOptions = <
+	TData = Awaited<ReturnType<typeof getSystemDashboard>>,
+	TError = ErrorType<RenderErrorResponseDTO>,
+>(
+	{ name }: GetSystemDashboardPathParameters,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getSystemDashboard>>,
+			TError,
+			TData
+		>;
+	},
+) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey =
+		queryOptions?.queryKey ?? getGetSystemDashboardQueryKey({ name });
+
+	const queryFn: QueryFunction<
+		Awaited<ReturnType<typeof getSystemDashboard>>
+	> = ({ signal }) => getSystemDashboard({ name }, signal);
+
+	return {
+		queryKey,
+		queryFn,
+		enabled: !!name,
+		...queryOptions,
+	} as UseQueryOptions<
+		Awaited<ReturnType<typeof getSystemDashboard>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type GetSystemDashboardQueryResult = NonNullable<
+	Awaited<ReturnType<typeof getSystemDashboard>>
+>;
+export type GetSystemDashboardQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Get system dashboard
+ */
+
+export function useGetSystemDashboard<
+	TData = Awaited<ReturnType<typeof getSystemDashboard>>,
+	TError = ErrorType<RenderErrorResponseDTO>,
+>(
+	{ name }: GetSystemDashboardPathParameters,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getSystemDashboard>>,
+			TError,
+			TData
+		>;
+	},
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getGetSystemDashboardQueryOptions({ name }, options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	return { ...query, queryKey: queryOptions.queryKey };
+}
+
+/**
+ * @summary Get system dashboard
+ */
+export const invalidateGetSystemDashboard = async (
+	queryClient: QueryClient,
+	{ name }: GetSystemDashboardPathParameters,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getGetSystemDashboardQueryKey({ name }) },
+		options,
+	);
+
+	return queryClient;
+};
+
 /**
  * This endpoint returns the sanitized v2-shape dashboard data for public access. Each panel query is reduced to a safe field subset, so filters and raw query strings are not exposed.
  * @summary Get public dashboard data (v2)

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/orgs/me/license`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetActiveLicenseQueryKey = () => {
-	return [`/api/v4/orgs/me/license`] 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

@@ -4960,6 +4960,53 @@ export interface DashboardtypesGettablePublicDashboardDataV2DTO {
 	publicDashboard?: DashboardtypesGettablePublicDasbhboardDTO;
 }
 
+export interface DashboardtypesGettableSystemDashboardDTO {
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	createdAt?: string;
+	/**
+	 * @type string
+	 */
+	createdBy?: string;
+	/**
+	 * @type string
+	 */
+	image?: string;
+	/**
+	 * @type boolean
+	 */
+	locked: boolean;
+	/**
+	 * @type string
+	 */
+	name: string;
+	/**
+	 * @type string
+	 */
+	orgId: string;
+	/**
+	 * @type string
+	 */
+	schemaVersion: string;
+	source: DashboardtypesSourceDTO;
+	spec: DashboardtypesDashboardSpecDTO;
+	/**
+	 * @type array,null
+	 */
+	tags: TagtypesGettableTagDTO[] | null;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	updatedAt?: string;
+	/**
+	 * @type string
+	 */
+	updatedBy?: string;
+}
+
 export enum DashboardtypesPatchOpDTO {
 	add = 'add',
 	remove = 'remove',
@@ -7173,197 +7220,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 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
  */
@@ -11504,6 +11360,17 @@ export type MigrateDashboardV2200 = {
 	status: string;
 };
 
+export type GetSystemDashboardPathParameters = {
+	name: string;
+};
+export type GetSystemDashboard200 = {
+	data: DashboardtypesGettableSystemDashboardDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
 export type GetFeatures200 = {
 	/**
 	 * @type array
@@ -12620,42 +12487,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: LicensetypesGettableLicenseDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetWaterfallV4PathParameters = {
 	traceID: string;
 };

pkg/apiserver/signozapiserver/dashboard.go

@@ -332,6 +332,33 @@ func (provider *provider) addDashboardRoutes(router *mux.Router) error {
 		return err
 	}
 
+	if err := router.Handle("/api/v2/dashboards/system/{name}", handler.New(
+		provider.authzMiddleware.CheckResources(provider.dashboardHandler.GetSystemDashboard, authtypes.SigNozAdminRoleName, authtypes.SigNozEditorRoleName, authtypes.SigNozViewerRoleName),
+		handler.OpenAPIDef{
+			ID:                  "GetSystemDashboard",
+			Tags:                []string{"dashboard"},
+			Summary:             "Get system dashboard",
+			Description:         "Returns a dashboard SigNoz ships and owns, addressed by its stable definition name (e.g. `ai-o11y-overview`) rather than its id. System dashboards are read-only and upgraded through releases. The dashboard's own `name` field carries a reserved prefix that the path segment must not include.",
+			Request:             nil,
+			RequestContentType:  "",
+			Response:            new(dashboardtypes.GettableSystemDashboard),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusOK,
+			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
+			Deprecated:          false,
+			SecuritySchemes:     newScopedSecuritySchemes([]string{coretypes.ResourceMetaResourceDashboard.Scope(coretypes.VerbRead)}),
+		},
+		handler.WithResourceDefs(handler.BasicResourceDef{
+			Resource: coretypes.ResourceMetaResourceDashboard,
+			Verb:     coretypes.VerbRead,
+			Category: coretypes.ActionCategoryDataAccess,
+			ID:       provider.systemDashboardID(),
+			Selector: coretypes.IDSelector,
+		}),
+	)).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
 	// Pinning mutates the calling user's pin list, not the dashboard, so it rides
 	// on the collection-level list permission rather than a per-dashboard check.
 	// The id is still extracted, for audit.
@@ -718,3 +745,23 @@ func (provider *provider) addDashboardRoutes(router *mux.Router) error {
 
 	return nil
 }
+
+// systemDashboardID resolves the {name} path param to the dashboard's id. Authz
+// tuples and audit records are written against ids, so the name has to be
+// resolved before either runs.
+func (provider *provider) systemDashboardID() coretypes.ResourceIDExtractor {
+	return coretypes.NewResourceIDExtractor(coretypes.PhaseRequest, func(ec coretypes.ExtractorContext) (string, error) {
+		ctx := ec.Request.Context()
+		claims, err := authtypes.ClaimsFromContext(ctx)
+		if err != nil {
+			return "", err
+		}
+
+		systemDashboard, err := provider.dashboardModule.GetSystemDashboard(ctx, valuer.MustNewUUID(claims.OrgID), mux.Vars(ec.Request)["name"])
+		if err != nil {
+			return "", err
+		}
+
+		return systemDashboard.ID.StringValue(), nil
+	})
+}

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/orgs/me/license", 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.GettableLicense),
-		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/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.NewGettableLicense(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/modules/dashboard/dashboard.go

@@ -99,6 +99,14 @@ type Module interface {
 	DeleteView(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
 
 	GetByMetricNamesV2(ctx context.Context, orgID valuer.UUID, metricNames []string) (map[string][]dashboardtypes.DashboardPanelRef, error)
+
+	// ════════════════════════════════════════════════════════════════════════
+	// System dashboard methods
+	// ════════════════════════════════════════════════════════════════════════
+
+	ReconcileSystemDashboards(ctx context.Context, orgID valuer.UUID) error
+
+	GetSystemDashboard(ctx context.Context, orgID valuer.UUID, name string) (*dashboardtypes.DashboardV2, error)
 }
 
 type Handler interface {
@@ -162,4 +170,6 @@ type Handler interface {
 	UpdateView(http.ResponseWriter, *http.Request)
 
 	DeleteView(http.ResponseWriter, *http.Request)
+
+	GetSystemDashboard(http.ResponseWriter, *http.Request)
 }

pkg/modules/dashboard/impldashboard/fs/definitions/ai-o11y-overview.json

@@ -0,0 +1,17 @@
+{
+  "version": 1,
+  "definition": {
+    "schemaVersion": "v6",
+    "name": "signoz---ai-o11y-overview",
+    "tags": [],
+    "spec": {
+      "display": {
+        "name": "AI Observability Overview",
+        "description": "Overview of LLM traffic. Panels ship in an upcoming release."
+      },
+      "variables": [],
+      "panels": {},
+      "layouts": []
+    }
+  }
+}

pkg/modules/dashboard/impldashboard/module.go

@@ -21,23 +21,25 @@ import (
 )
 
 type module struct {
-	store       dashboardtypes.Store
-	settings    factory.ScopedProviderSettings
-	analytics   analytics.Analytics
-	orgGetter   organization.Getter
-	queryParser queryparser.QueryParser
-	tagModule   tag.Module
+	store                   dashboardtypes.Store
+	settings                factory.ScopedProviderSettings
+	analytics               analytics.Analytics
+	orgGetter               organization.Getter
+	queryParser             queryparser.QueryParser
+	tagModule               tag.Module
+	systemDashboardRegistry dashboardtypes.SystemDashboardRegistry
 }
 
-func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, tagModule tag.Module) dashboard.Module {
+func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, tagModule tag.Module, systemDashboardRegistry dashboardtypes.SystemDashboardRegistry) dashboard.Module {
 	scopedProviderSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard")
 	return &module{
-		store:       store,
-		settings:    scopedProviderSettings,
-		analytics:   analytics,
-		orgGetter:   orgGetter,
-		queryParser: queryParser,
-		tagModule:   tagModule,
+		store:                   store,
+		settings:                scopedProviderSettings,
+		analytics:               analytics,
+		orgGetter:               orgGetter,
+		queryParser:             queryParser,
+		tagModule:               tagModule,
+		systemDashboardRegistry: systemDashboardRegistry,
 	}
 }
 

pkg/modules/dashboard/impldashboard/store.go

@@ -3,6 +3,7 @@ package impldashboard
 import (
 	"context"
 	"strings"
+	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
@@ -64,6 +65,23 @@ func (store *store) Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID)
 	return storableDashboard, nil
 }
 
+func (store *store) GetByName(ctx context.Context, orgID valuer.UUID, name string) (*dashboardtypes.StorableDashboard, error) {
+	storableDashboard := new(dashboardtypes.StorableDashboard)
+	err := store.
+		sqlstore.
+		BunDB().
+		NewSelect().
+		Model(storableDashboard).
+		Where("name = ?", name).
+		Where("org_id = ?", orgID).
+		Scan(ctx)
+	if err != nil {
+		return nil, store.sqlstore.WrapNotFoundErrf(err, errors.CodeNotFound, "dashboard with name %s doesn't exist", name)
+	}
+
+	return storableDashboard, nil
+}
+
 // ListForUser emits the joined dashboard ⨝ user_dashboard_preference query the
 // spec calls for. Aliases:
 //
@@ -613,3 +631,60 @@ func (store *store) DeleteDashboardView(ctx context.Context, orgID valuer.UUID,
 	}
 	return nil
 }
+
+func (store *store) CreateSystemDashboard(ctx context.Context, storable *dashboardtypes.StorableSystemDashboard) error {
+	_, err := store.
+		sqlstore.
+		BunDBCtx(ctx).
+		NewInsert().
+		Model(storable).
+		Exec(ctx)
+	if err != nil {
+		return store.sqlstore.WrapAlreadyExistsErrf(err, dashboardtypes.ErrCodeSystemDashboardAlreadyProvisioned, "system dashboard %s is already provisioned", storable.Name)
+	}
+
+	return nil
+}
+
+func (store *store) GetSystemDashboard(ctx context.Context, orgID valuer.UUID, name string) (*dashboardtypes.StorableSystemDashboard, error) {
+	storable := new(dashboardtypes.StorableSystemDashboard)
+	err := store.
+		sqlstore.
+		BunDBCtx(ctx).
+		NewSelect().
+		Model(storable).
+		Where("org_id = ?", orgID).
+		Where("name = ?", name).
+		Scan(ctx)
+	if err != nil {
+		return nil, store.sqlstore.WrapNotFoundErrf(err, dashboardtypes.ErrCodeSystemDashboardNotFound, "system dashboard %s is not provisioned", name)
+	}
+
+	return storable, nil
+}
+
+func (store *store) UpdateSystemDashboardVersion(ctx context.Context, orgID valuer.UUID, name string, version int) error {
+	result, err := store.
+		sqlstore.
+		BunDBCtx(ctx).
+		NewUpdate().
+		Model(new(dashboardtypes.StorableSystemDashboard)).
+		Set("version = ?", version).
+		Set("updated_at = ?", time.Now()).
+		Where("org_id = ?", orgID).
+		Where("name = ?", name).
+		Exec(ctx)
+	if err != nil {
+		return err
+	}
+
+	rows, err := result.RowsAffected()
+	if err != nil {
+		return err
+	}
+	if rows == 0 {
+		return errors.Newf(errors.TypeNotFound, dashboardtypes.ErrCodeSystemDashboardNotFound, "system dashboard %s is not provisioned", name)
+	}
+
+	return nil
+}

pkg/modules/dashboard/impldashboard/system_dashboard_definitions.go

@@ -0,0 +1,46 @@
+package impldashboard
+
+import (
+	"embed"
+	"io/fs"
+	"path"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
+)
+
+const definitionsRoot = "fs/definitions"
+
+//go:embed fs/definitions/*.json
+var definitionFiles embed.FS
+
+// NewSystemDashboardRegistry parses every embedded definition. Definitions are
+// build-time assets validated by a test, so a failure here means the binary
+// shipped broken JSON.
+func NewSystemDashboardRegistry() (dashboardtypes.SystemDashboardRegistry, error) {
+	entries, err := fs.ReadDir(definitionFiles, definitionsRoot)
+	if err != nil {
+		return dashboardtypes.SystemDashboardRegistry{}, errors.WrapInternalf(err, errors.CodeInternal, "couldn't read system dashboard definitions")
+	}
+
+	definitions := make([]dashboardtypes.SystemDashboardDefinition, 0, len(entries))
+	for _, entry := range entries {
+		if entry.IsDir() {
+			continue
+		}
+
+		file := path.Join(definitionsRoot, entry.Name())
+		raw, err := definitionFiles.ReadFile(file)
+		if err != nil {
+			return dashboardtypes.SystemDashboardRegistry{}, errors.WrapInternalf(err, errors.CodeInternal, "couldn't read %s", file)
+		}
+
+		definition, err := dashboardtypes.NewSystemDashboardDefinition(raw)
+		if err != nil {
+			return dashboardtypes.SystemDashboardRegistry{}, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "couldn't parse %s", file)
+		}
+		definitions = append(definitions, definition)
+	}
+
+	return dashboardtypes.NewSystemDashboardRegistry(definitions)
+}

pkg/modules/dashboard/impldashboard/system_dashboard_service.go

@@ -0,0 +1,81 @@
+package impldashboard
+
+import (
+	"context"
+	"log/slog"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/modules/dashboard"
+	"github.com/SigNoz/signoz/pkg/modules/organization"
+)
+
+const reconcileRetryInterval = 30 * time.Second
+
+type service struct {
+	settings  factory.ScopedProviderSettings
+	module    dashboard.Module
+	orgGetter organization.Getter
+	stopC     chan struct{}
+	healthyC  chan struct{}
+}
+
+// NewService reconciles every org's system dashboards once at startup. Orgs
+// created later are reconciled by the organization setter instead.
+func NewService(providerSettings factory.ProviderSettings, module dashboard.Module, orgGetter organization.Getter) factory.Service {
+	return &service{
+		settings:  factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"),
+		module:    module,
+		orgGetter: orgGetter,
+		stopC:     make(chan struct{}),
+		healthyC:  make(chan struct{}),
+	}
+}
+
+func (service *service) Start(ctx context.Context) error {
+	ticker := time.NewTicker(reconcileRetryInterval)
+	defer ticker.Stop()
+
+	for {
+		err := service.reconcile(ctx)
+		if err == nil {
+			close(service.healthyC)
+			<-service.stopC
+			return nil
+		}
+
+		service.settings.Logger().WarnContext(ctx, "system dashboard reconciliation failed, retrying", errors.Attr(err))
+
+		select {
+		case <-service.stopC:
+			return nil
+		case <-ticker.C:
+		}
+	}
+}
+
+func (service *service) Healthy() <-chan struct{} {
+	return service.healthyC
+}
+
+func (service *service) Stop(_ context.Context) error {
+	close(service.stopC)
+	return nil
+}
+
+func (service *service) reconcile(ctx context.Context) error {
+	orgs, err := service.orgGetter.ListByOwnedKeyRange(ctx)
+	if err != nil {
+		return err
+	}
+
+	for _, org := range orgs {
+		if err := service.module.ReconcileSystemDashboards(ctx, org.ID); err != nil {
+			return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "couldn't reconcile system dashboards for org %s", org.ID.StringValue())
+		}
+	}
+
+	service.settings.Logger().InfoContext(ctx, "system dashboard reconciliation completed", slog.Int("orgs", len(orgs)))
+	return nil
+}

pkg/modules/dashboard/impldashboard/v2_handler.go

@@ -502,3 +502,28 @@ func (handler *handler) GetPublicWidgetQueryRangeV2(rw http.ResponseWriter, r *h
 
 	render.Success(rw, http.StatusOK, queryRangeResults)
 }
+
+func (handler *handler) GetSystemDashboard(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
+	}
+
+	name := mux.Vars(r)["name"]
+	if name == "" {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "name is missing in the path"))
+		return
+	}
+
+	systemDashboard, err := handler.module.GetSystemDashboard(ctx, valuer.MustNewUUID(claims.OrgID), name)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, systemDashboard.ToGettableSystemDashboard())
+}

pkg/modules/dashboard/impldashboard/v2_module.go

@@ -2,6 +2,8 @@ package impldashboard
 
 import (
 	"context"
+	"log/slog"
+	"strings"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/transition"
@@ -19,9 +21,12 @@ func (m *module) CreateV2(ctx context.Context, orgID valuer.UUID, createdBy stri
 		return nil, err
 	}
 
-	dashboard := postable.NewDashboardV2(orgID, createdBy, source)
+	dashboard, err := postable.NewDashboardV2(orgID, createdBy, source)
+	if err != nil {
+		return nil, err
+	}
 
-	err := m.store.RunInTx(ctx, func(ctx context.Context) error {
+	err = m.store.RunInTx(ctx, func(ctx context.Context) error {
 		resolvedTags, err := m.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, dashboard.ID, postable.Tags)
 		if err != nil {
 			return err
@@ -120,6 +125,20 @@ func (module *module) GetV2(ctx context.Context, orgID valuer.UUID, id valuer.UU
 	return storable.ToDashboardV2(tags)
 }
 
+func (module *module) getByNameV2(ctx context.Context, orgID valuer.UUID, name string) (*dashboardtypes.DashboardV2, error) {
+	storable, err := module.store.GetByName(ctx, orgID, name)
+	if err != nil {
+		return nil, err
+	}
+
+	tags, err := module.tagModule.ListForResource(ctx, orgID, coretypes.KindDashboard, storable.ID)
+	if err != nil {
+		return nil, err
+	}
+
+	return storable.ToDashboardV2(tags)
+}
+
 // MigrateV2 retries the v1→v2 migration on a dashboard still stored as v1 (one the
 // bulk 103 migration skipped or failed). Idempotent: an already-v2 one is unchanged.
 func (module *module) MigrateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardV2, error) {
@@ -179,13 +198,33 @@ func (module *module) UpdateV2(ctx context.Context, orgID valuer.UUID, id valuer
 		return nil, err
 	}
 
-	err = module.store.RunInTx(ctx, func(ctx context.Context) error {
-		resolvedTags, err := module.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, id, updatable.Tags)
+	return module.updateV2(ctx, orgID, existing, updatedBy, updatable, existing.Update)
+}
+
+// updateUnsafeV2 updates a dashboard bypassing the guards. Intended for internal system callers.
+func (module *module) updateUnsafeV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, updatable dashboardtypes.UpdatableDashboardV2) (*dashboardtypes.DashboardV2, error) {
+	if err := updatable.Validate(); err != nil {
+		return nil, err
+	}
+
+	existing, err := module.GetV2(ctx, orgID, id)
+	if err != nil {
+		return nil, err
+	}
+
+	return module.updateV2(ctx, orgID, existing, updatedBy, updatable, existing.UpdateUnsafe)
+}
+
+// apply is existing.Update or existing.UpdateUnsafe, so the gated path keeps its
+// in-transaction checks and only updateUnsafeV2 skips them.
+func (module *module) updateV2(ctx context.Context, orgID valuer.UUID, existing *dashboardtypes.DashboardV2, updatedBy string, updatable dashboardtypes.UpdatableDashboardV2, apply func(dashboardtypes.UpdatableDashboardV2, string, []*tagtypes.Tag) error) (*dashboardtypes.DashboardV2, error) {
+	err := module.store.RunInTx(ctx, func(ctx context.Context) error {
+		resolvedTags, err := module.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, existing.ID, updatable.Tags)
 		if err != nil {
 			return err
 		}
 
-		err = existing.Update(updatable, updatedBy, resolvedTags)
+		err = apply(updatable, updatedBy, resolvedTags)
 		if err != nil {
 			return err
 		}
@@ -296,3 +335,98 @@ func (module *module) UnpinV2(ctx context.Context, orgID valuer.UUID, userID val
 func (module *module) DeletePreferencesForUser(ctx context.Context, orgID valuer.UUID, userID valuer.UUID) error {
 	return module.store.DeletePreferencesForUser(ctx, orgID, userID)
 }
+
+func (m *module) ReconcileSystemDashboards(ctx context.Context, orgID valuer.UUID) error {
+	for _, definition := range m.systemDashboardRegistry.List() {
+		if err := m.reconcileSystemDashboard(ctx, orgID, definition); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (m *module) reconcileSystemDashboard(ctx context.Context, orgID valuer.UUID, definition dashboardtypes.SystemDashboardDefinition) error {
+	existing, err := m.getByNameV2(ctx, orgID, definition.Name())
+	if err != nil {
+		if !errors.Ast(err, errors.TypeNotFound) {
+			return err
+		}
+		return m.provisionSystemDashboard(ctx, orgID, definition)
+	}
+
+	state, err := m.store.GetSystemDashboard(ctx, orgID, definition.Name())
+	if err != nil {
+		return err
+	}
+	// Only ever move forward: a downgrade must not rewrite the newer content.
+	if state.Version >= definition.Version {
+		return nil
+	}
+
+	return m.upgradeSystemDashboard(ctx, orgID, existing.ID, definition)
+}
+
+// provisionSystemDashboard creates the dashboard and its state row in one transaction,
+// so a system dashboard can never exist without the version it was provisioned at.
+// A concurrent provisioner (another replica, or the org-creation hook racing the
+// startup sweep) loses on the state row's unique (org_id, name) index and rolls back.
+func (m *module) provisionSystemDashboard(ctx context.Context, orgID valuer.UUID, definition dashboardtypes.SystemDashboardDefinition) error {
+	err := m.store.RunInTx(ctx, func(ctx context.Context) error {
+		created, err := m.CreateV2(
+			ctx,
+			orgID,
+			dashboardtypes.ProvisionerIdentity,
+			valuer.UUID{},
+			dashboardtypes.SourceSystem,
+			definition.Dashboard,
+		)
+		if err != nil {
+			return err
+		}
+
+		return m.store.CreateSystemDashboard(ctx, dashboardtypes.NewStorableSystemDashboard(orgID, created.ID, definition.Name(), definition.Version))
+	})
+	if err != nil {
+		if errors.Ast(err, errors.TypeAlreadyExists) {
+			m.settings.Logger().DebugContext(ctx, "system dashboard already provisioned concurrently", slog.String("name", definition.Name()), slog.String("org_id", orgID.StringValue()))
+			return nil
+		}
+		return err
+	}
+
+	m.settings.Logger().InfoContext(ctx, "provisioned system dashboard", slog.String("name", definition.Name()), slog.Int("version", definition.Version), slog.String("org_id", orgID.StringValue()))
+	return nil
+}
+
+func (m *module) upgradeSystemDashboard(ctx context.Context, orgID valuer.UUID, id valuer.UUID, definition dashboardtypes.SystemDashboardDefinition) error {
+	err := m.store.RunInTx(ctx, func(ctx context.Context) error {
+		if _, err := m.updateUnsafeV2(ctx, orgID, id, dashboardtypes.ProvisionerIdentity, definition.ToUpdatable()); err != nil {
+			return err
+		}
+
+		return m.store.UpdateSystemDashboardVersion(ctx, orgID, definition.Name(), definition.Version)
+	})
+	if err != nil {
+		return err
+	}
+
+	m.settings.Logger().InfoContext(ctx, "upgraded system dashboard", slog.String("name", definition.Name()), slog.Int("version", definition.Version), slog.String("org_id", orgID.StringValue()))
+	return nil
+}
+
+func (m *module) GetSystemDashboard(ctx context.Context, orgID valuer.UUID, name string) (*dashboardtypes.DashboardV2, error) {
+	if strings.HasPrefix(name, dashboardtypes.SystemDashboardNamePrefix) {
+		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "name must not carry the %q prefix", dashboardtypes.SystemDashboardNamePrefix)
+	}
+
+	existing, err := m.getByNameV2(ctx, orgID, dashboardtypes.SystemDashboardNamePrefix+name)
+	if err != nil {
+		return nil, err
+	}
+	if err := existing.ErrIfNotSystem(); err != nil {
+		return nil, err
+	}
+
+	return existing, nil
+}

pkg/modules/dashboard/impldashboard/v2_module_test.go

@@ -0,0 +1,191 @@
+package impldashboard
+
+import (
+	"context"
+	"path/filepath"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/analytics/analyticstest"
+	"github.com/SigNoz/signoz/pkg/factory/factorytest"
+	"github.com/SigNoz/signoz/pkg/modules/tag/impltag"
+	"github.com/SigNoz/signoz/pkg/queryparser"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/sqlstore/sqlitesqlstore"
+	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
+	"github.com/SigNoz/signoz/pkg/types/tagtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const testDashboardName = "test-overview"
+
+func newTestSQLStore(t *testing.T) sqlstore.SQLStore {
+	t.Helper()
+
+	store, err := sqlitesqlstore.New(context.Background(), factorytest.NewSettings(), sqlstore.Config{
+		Provider:   "sqlite",
+		Connection: sqlstore.ConnectionConfig{MaxOpenConns: 10},
+		Sqlite: sqlstore.SqliteConfig{
+			Path:            filepath.Join(t.TempDir(), "test.db"),
+			Mode:            "wal",
+			BusyTimeout:     5 * time.Second,
+			TransactionMode: "deferred",
+		},
+	})
+	require.NoError(t, err)
+
+	for _, model := range []any{
+		(*dashboardtypes.StorableDashboard)(nil),
+		(*tagtypes.Tag)(nil),
+		(*tagtypes.TagRelation)(nil),
+		(*dashboardtypes.StorableSystemDashboard)(nil),
+	} {
+		_, err := store.BunDB().NewCreateTable().Model(model).IfNotExists().Exec(context.Background())
+		require.NoError(t, err)
+	}
+
+	_, err = store.BunDB().Exec(`CREATE UNIQUE INDEX IF NOT EXISTS uq_system_dashboard_org_name ON system_dashboard (org_id, name)`)
+	require.NoError(t, err)
+
+	return store
+}
+
+func newTestModule(t *testing.T, sqlStore sqlstore.SQLStore, definitions ...dashboardtypes.SystemDashboardDefinition) *module {
+	t.Helper()
+
+	registry, err := dashboardtypes.NewSystemDashboardRegistry(definitions)
+	require.NoError(t, err)
+
+	providerSettings := factorytest.NewSettings()
+	return NewModule(
+		NewStore(sqlStore),
+		providerSettings,
+		analyticstest.New(),
+		nil,
+		queryparser.New(providerSettings),
+		impltag.NewModule(impltag.NewStore(sqlStore)),
+		registry,
+	).(*module)
+}
+
+func newTestDefinition(t *testing.T, version int, displayName string) dashboardtypes.SystemDashboardDefinition {
+	t.Helper()
+
+	raw := `{
+		"version": ` + strconv.Itoa(version) + `,
+		"definition": {
+			"schemaVersion": "` + dashboardtypes.SchemaVersion + `",
+			"name": "` + dashboardtypes.SystemDashboardNamePrefix + testDashboardName + `",
+			"tags": [],
+			"spec": {"display": {"name": "` + displayName + `"}, "variables": [], "panels": {}, "layouts": []}
+		}
+	}`
+
+	definition, err := dashboardtypes.NewSystemDashboardDefinition([]byte(raw))
+	require.NoError(t, err)
+
+	return definition
+}
+
+func TestReconcileProvisionsThenUpgrades(t *testing.T) {
+	ctx := context.Background()
+	sqlStore := newTestSQLStore(t)
+	orgID := valuer.GenerateUUID()
+
+	dashboardModule := newTestModule(t, sqlStore, newTestDefinition(t, 1, "v1"))
+	require.NoError(t, dashboardModule.ReconcileSystemDashboards(ctx, orgID))
+
+	provisioned, err := dashboardModule.GetSystemDashboard(ctx, orgID, testDashboardName)
+	require.NoError(t, err)
+	assert.Equal(t, dashboardtypes.SourceSystem, provisioned.Source)
+	assert.Equal(t, dashboardtypes.ProvisionerIdentity, provisioned.CreatedBy)
+	assert.Equal(t, "v1", provisioned.Spec.Display.Name)
+	assert.Equal(t, 1, stateVersion(t, dashboardModule, ctx, orgID))
+
+	// Reconciling the same version again is a no-op.
+	require.NoError(t, dashboardModule.ReconcileSystemDashboards(ctx, orgID))
+	unchanged, err := dashboardModule.GetSystemDashboard(ctx, orgID, testDashboardName)
+	require.NoError(t, err)
+	assert.Equal(t, provisioned.UpdatedAt, unchanged.UpdatedAt)
+
+	// An unmodified copy is upgraded in place, keeping its id.
+	upgradingModule := newTestModule(t, sqlStore, newTestDefinition(t, 2, "v2"))
+	require.NoError(t, upgradingModule.ReconcileSystemDashboards(ctx, orgID))
+
+	upgraded, err := upgradingModule.GetSystemDashboard(ctx, orgID, testDashboardName)
+	require.NoError(t, err)
+	assert.Equal(t, provisioned.ID, upgraded.ID)
+	assert.Equal(t, "v2", upgraded.Spec.Display.Name)
+	assert.Equal(t, 2, stateVersion(t, upgradingModule, ctx, orgID))
+}
+
+func stateVersion(t *testing.T, module *module, ctx context.Context, orgID valuer.UUID) int {
+	t.Helper()
+
+	state, err := module.store.GetSystemDashboard(ctx, orgID, dashboardtypes.SystemDashboardNamePrefix+testDashboardName)
+	require.NoError(t, err)
+
+	return state.Version
+}
+
+func TestSystemDashboardsAreImmutableToUsers(t *testing.T) {
+	ctx := context.Background()
+	sqlStore := newTestSQLStore(t)
+	orgID := valuer.GenerateUUID()
+
+	dashboardModule := newTestModule(t, sqlStore, newTestDefinition(t, 1, "v1"))
+	require.NoError(t, dashboardModule.ReconcileSystemDashboards(ctx, orgID))
+
+	provisioned, err := dashboardModule.GetSystemDashboard(ctx, orgID, testDashboardName)
+	require.NoError(t, err)
+
+	_, err = dashboardModule.UpdateV2(ctx, orgID, provisioned.ID, "user@signoz.io", newTestDefinition(t, 1, "edited").ToUpdatable())
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "cannot be modified")
+}
+
+func TestReconcileDoesNotDowngrade(t *testing.T) {
+	ctx := context.Background()
+	sqlStore := newTestSQLStore(t)
+	orgID := valuer.GenerateUUID()
+
+	newerModule := newTestModule(t, sqlStore, newTestDefinition(t, 3, "v3"))
+	require.NoError(t, newerModule.ReconcileSystemDashboards(ctx, orgID))
+
+	olderModule := newTestModule(t, sqlStore, newTestDefinition(t, 2, "v2"))
+	require.NoError(t, olderModule.ReconcileSystemDashboards(ctx, orgID))
+
+	got, err := newerModule.GetSystemDashboard(ctx, orgID, testDashboardName)
+	require.NoError(t, err)
+	assert.Equal(t, "v3", got.Spec.Display.Name)
+	assert.Equal(t, 3, stateVersion(t, newerModule, ctx, orgID))
+}
+
+func TestGetRejectsANonSystemDashboard(t *testing.T) {
+	ctx := context.Background()
+	sqlStore := newTestSQLStore(t)
+	orgID := valuer.GenerateUUID()
+
+	dashboardModule := newTestModule(t, sqlStore)
+
+	var postable dashboardtypes.PostableDashboardV2
+	require.NoError(t, postable.UnmarshalJSON([]byte(`{
+		"schemaVersion": "`+dashboardtypes.SchemaVersion+`",
+		"name": "a-user-dashboard",
+		"tags": [],
+		"spec": {"display": {"name": "user"}, "variables": [], "panels": {}, "layouts": []}
+	}`)))
+	_, err := dashboardModule.CreateV2(ctx, orgID, "user@signoz.io", valuer.GenerateUUID(), dashboardtypes.SourceUser, postable)
+	require.NoError(t, err)
+
+	// The server-side prefix makes user names structurally unreachable here.
+	_, err = dashboardModule.GetSystemDashboard(ctx, orgID, "a-user-dashboard")
+	require.Error(t, err)
+
+	_, err = dashboardModule.GetSystemDashboard(ctx, orgID, dashboardtypes.SystemDashboardNamePrefix+testDashboardName)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "must not carry")
+}

pkg/modules/organization/implorganization/setter.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/SigNoz/signoz/pkg/alertmanager"
+	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/quickfilter"
 	"github.com/SigNoz/signoz/pkg/types"
@@ -14,10 +15,11 @@ type setter struct {
 	store        types.OrganizationStore
 	alertmanager alertmanager.Alertmanager
 	quickfilter  quickfilter.Module
+	dashboard    dashboard.Module
 }
 
-func NewSetter(store types.OrganizationStore, alertmanager alertmanager.Alertmanager, quickfilter quickfilter.Module) organization.Setter {
-	return &setter{store: store, alertmanager: alertmanager, quickfilter: quickfilter}
+func NewSetter(store types.OrganizationStore, alertmanager alertmanager.Alertmanager, quickfilter quickfilter.Module, dashboard dashboard.Module) organization.Setter {
+	return &setter{store: store, alertmanager: alertmanager, quickfilter: quickfilter, dashboard: dashboard}
 }
 
 func (module *setter) Create(ctx context.Context, organization *types.Organization, createManagedRoles func(context.Context, valuer.UUID) error) error {
@@ -37,6 +39,10 @@ func (module *setter) Create(ctx context.Context, organization *types.Organizati
 		return err
 	}
 
+	if err := module.dashboard.ReconcileSystemDashboards(ctx, organization.ID); err != nil {
+		return err
+	}
+
 	return nil
 }
 

pkg/query-service/app/http_handler.go

@@ -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

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/handler_test.go

@@ -49,7 +49,9 @@ func TestNewHandlers(t *testing.T) {
 	queryParser := queryparser.New(providerSettings)
 	require.NoError(t, err)
 	tagModule := impltag.NewModule(impltag.NewStore(sqlstore))
-	dashboardModule := impldashboard.NewModule(impldashboard.NewStore(sqlstore), providerSettings, nil, orgGetter, queryParser, tagModule)
+	systemDashboardRegistry, err := impldashboard.NewSystemDashboardRegistry()
+	require.NoError(t, err)
+	dashboardModule := impldashboard.NewModule(impldashboard.NewStore(sqlstore), providerSettings, nil, orgGetter, queryParser, tagModule, systemDashboardRegistry)
 
 	flagger, err := flagger.New(context.Background(), instrumentationtest.New().ToProviderSettings(), flagger.Config{}, flagger.MustNewRegistry())
 	require.NoError(t, err)

pkg/signoz/module.go

@@ -67,35 +67,35 @@ import (
 )
 
 type Modules struct {
-	OrgGetter           organization.Getter
-	OrgSetter           organization.Setter
-	Preference          preference.Module
-	UserSetter          user.Setter
-	UserGetter          user.Getter
-	RetentionGetter     retention.Getter
-	SavedView           savedview.Module
-	Apdex               apdex.Module
-	Dashboard           dashboard.Module
-	QuickFilter         quickfilter.Module
-	TraceFunnel         tracefunnel.Module
-	RawDataExport       rawdataexport.Module
-	AuthDomain          authdomain.Module
-	Session             session.Module
-	Services            services.Module
-	SpanPercentile      spanpercentile.Module
-	MetricsExplorer     metricsexplorer.Module
-	MetricReductionRule metricreductionrule.Module
-	InfraMonitoring     inframonitoring.Module
+	OrgGetter            organization.Getter
+	OrgSetter            organization.Setter
+	Preference           preference.Module
+	UserSetter           user.Setter
+	UserGetter           user.Getter
+	RetentionGetter      retention.Getter
+	SavedView            savedview.Module
+	Apdex                apdex.Module
+	Dashboard            dashboard.Module
+	QuickFilter          quickfilter.Module
+	TraceFunnel          tracefunnel.Module
+	RawDataExport        rawdataexport.Module
+	AuthDomain           authdomain.Module
+	Session              session.Module
+	Services             services.Module
+	SpanPercentile       spanpercentile.Module
+	MetricsExplorer      metricsexplorer.Module
+	MetricReductionRule  metricreductionrule.Module
+	InfraMonitoring      inframonitoring.Module
 	Promote              promote.Module
 	ServiceAccount       serviceaccount.Module
 	ServiceAccountGetter serviceaccount.Getter
 	CloudIntegration     cloudintegration.Module
-	LogsPipeline        logspipeline.Module
-	RuleStateHistory    rulestatehistory.Module
-	TraceDetail         tracedetail.Module
-	SpanMapper          spanmapper.Module
-	LLMPricingRule      llmpricingrule.Module
-	Tag                 tag.Module
+	LogsPipeline         logspipeline.Module
+	RuleStateHistory     rulestatehistory.Module
+	TraceDetail          tracedetail.Module
+	SpanMapper           spanmapper.Module
+	LLMPricingRule       llmpricingrule.Module
+	Tag                  tag.Module
 }
 
 func NewModules(
@@ -126,7 +126,7 @@ func NewModules(
 	metricReductionRule metricreductionrule.Module,
 ) Modules {
 	quickfilter := implquickfilter.NewModule(implquickfilter.NewStore(sqlstore))
-	orgSetter := implorganization.NewSetter(implorganization.NewStore(sqlstore), alertmanager, quickfilter)
+	orgSetter := implorganization.NewSetter(implorganization.NewStore(sqlstore), alertmanager, quickfilter, dashboard)
 	// Cleanup callbacks from other modules, invoked when a user is deleted.
 	onDeleteUser := []user.OnDeleteUser{
 		dashboard.DeletePreferencesForUser,
@@ -136,34 +136,34 @@ func NewModules(
 	authDomainModule := implauthdomain.NewModule(implauthdomain.NewStore(sqlstore), authNs, authz)
 
 	return Modules{
-		OrgGetter:           orgGetter,
-		OrgSetter:           orgSetter,
-		Preference:          implpreference.NewModule(implpreference.NewStore(sqlstore), preferencetypes.NewAvailablePreference()),
-		SavedView:           implsavedview.NewModule(implsavedview.NewStore(sqlstore)),
-		Apdex:               implapdex.NewModule(sqlstore),
-		Dashboard:           dashboard,
-		UserSetter:          userSetter,
-		UserGetter:          userGetter,
-		RetentionGetter:     retentionGetter,
-		QuickFilter:         quickfilter,
-		TraceFunnel:         impltracefunnel.NewModule(impltracefunnel.NewStore(sqlstore)),
-		RawDataExport:       implrawdataexport.NewModule(querier),
-		AuthDomain:          authDomainModule,
-		Session:             implsession.NewModule(providerSettings, authNs, userSetter, userGetter, authDomainModule, tokenizer, orgGetter, authz, config.Global),
-		SpanPercentile:      implspanpercentile.NewModule(querier, providerSettings),
-		Services:            implservices.NewModule(querier, telemetryStore),
-		MetricsExplorer:     implmetricsexplorer.NewModule(telemetryStore, telemetryMetadataStore, cache, ruleStore, dashboard, fl, providerSettings, config.MetricsExplorer),
-		MetricReductionRule: metricReductionRule,
-		InfraMonitoring:     implinframonitoring.NewModule(telemetryStore, telemetryMetadataStore, querier, fl, providerSettings, config.InfraMonitoring),
-		Promote:             implpromote.NewModule(telemetryMetadataStore, telemetryStore),
+		OrgGetter:            orgGetter,
+		OrgSetter:            orgSetter,
+		Preference:           implpreference.NewModule(implpreference.NewStore(sqlstore), preferencetypes.NewAvailablePreference()),
+		SavedView:            implsavedview.NewModule(implsavedview.NewStore(sqlstore)),
+		Apdex:                implapdex.NewModule(sqlstore),
+		Dashboard:            dashboard,
+		UserSetter:           userSetter,
+		UserGetter:           userGetter,
+		RetentionGetter:      retentionGetter,
+		QuickFilter:          quickfilter,
+		TraceFunnel:          impltracefunnel.NewModule(impltracefunnel.NewStore(sqlstore)),
+		RawDataExport:        implrawdataexport.NewModule(querier),
+		AuthDomain:           authDomainModule,
+		Session:              implsession.NewModule(providerSettings, authNs, userSetter, userGetter, authDomainModule, tokenizer, orgGetter, authz, config.Global),
+		SpanPercentile:       implspanpercentile.NewModule(querier, providerSettings),
+		Services:             implservices.NewModule(querier, telemetryStore),
+		MetricsExplorer:      implmetricsexplorer.NewModule(telemetryStore, telemetryMetadataStore, cache, ruleStore, dashboard, fl, providerSettings, config.MetricsExplorer),
+		MetricReductionRule:  metricReductionRule,
+		InfraMonitoring:      implinframonitoring.NewModule(telemetryStore, telemetryMetadataStore, querier, fl, providerSettings, config.InfraMonitoring),
+		Promote:              implpromote.NewModule(telemetryMetadataStore, telemetryStore),
 		ServiceAccount:       serviceAccount,
 		ServiceAccountGetter: serviceAccountGetter,
-		LogsPipeline:        impllogspipeline.NewModule(sqlstore),
-		RuleStateHistory:    implrulestatehistory.NewModule(implrulestatehistory.NewStore(telemetryStore, telemetryMetadataStore, providerSettings.Logger), ruleStore),
-		CloudIntegration:    cloudIntegrationModule,
-		TraceDetail:         impltracedetail.NewModule(impltracedetail.NewTraceStore(telemetryStore), providerSettings, config.TraceDetail),
-		SpanMapper:          implspanmapper.NewModule(implspanmapper.NewStore(sqlstore), fl),
-		LLMPricingRule:      impllmpricingrule.NewModule(impllmpricingrule.NewStore(sqlstore), fl, querier),
-		Tag:                 tagModule,
+		LogsPipeline:         impllogspipeline.NewModule(sqlstore),
+		RuleStateHistory:     implrulestatehistory.NewModule(implrulestatehistory.NewStore(telemetryStore, telemetryMetadataStore, providerSettings.Logger), ruleStore),
+		CloudIntegration:     cloudIntegrationModule,
+		TraceDetail:          impltracedetail.NewModule(impltracedetail.NewTraceStore(telemetryStore), providerSettings, config.TraceDetail),
+		SpanMapper:           implspanmapper.NewModule(implspanmapper.NewStore(sqlstore), fl),
+		LLMPricingRule:       impllmpricingrule.NewModule(impllmpricingrule.NewStore(sqlstore), fl, querier),
+		Tag:                  tagModule,
 	}
 }

pkg/signoz/module_test.go

@@ -51,7 +51,9 @@ func TestNewModules(t *testing.T) {
 	queryParser := queryparser.New(providerSettings)
 	require.NoError(t, err)
 	tagModule := impltag.NewModule(impltag.NewStore(sqlstore))
-	dashboardModule := impldashboard.NewModule(impldashboard.NewStore(sqlstore), providerSettings, nil, orgGetter, queryParser, tagModule)
+	systemDashboardRegistry, err := impldashboard.NewSystemDashboardRegistry()
+	require.NoError(t, err)
+	dashboardModule := impldashboard.NewModule(impldashboard.NewStore(sqlstore), providerSettings, nil, orgGetter, queryParser, tagModule, systemDashboardRegistry)
 
 	flagger, err := flagger.New(context.Background(), instrumentationtest.New().ToProviderSettings(), flagger.Config{}, flagger.MustNewRegistry())
 	require.NoError(t, err)

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 }{},

pkg/signoz/provider.go

@@ -245,7 +245,7 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewMigrateLambdaDashboardsFactory(),
 		sqlmigration.NewAddAuthDomainTuplesFactory(sqlstore),
 		sqlmigration.NewAddDeploymentHostTuplesFactory(sqlstore),
-		sqlmigration.NewAddLicenseTuplesFactory(sqlstore),
+		sqlmigration.NewAddSystemDashboardFactory(sqlstore, sqlschema),
 	)
 }
 
@@ -336,7 +336,6 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			handlers.AuthzHandler,
 			handlers.RawDataExport,
 			handlers.ZeusHandler,
-			handlers.LicensingHandler,
 			handlers.QuerierHandler,
 			handlers.ServiceAccountHandler,
 			modules.ServiceAccountGetter,

pkg/signoz/signoz.go

@@ -60,6 +60,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	pkgtokenizer "github.com/SigNoz/signoz/pkg/tokenizer"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/version"
@@ -175,7 +176,7 @@ func New(
 	telemetrystoreProviderFactories factory.NamedMap[factory.ProviderFactory[telemetrystore.TelemetryStore, telemetrystore.Config]],
 	authNsCallback func(ctx context.Context, providerSettings factory.ProviderSettings, store authtypes.AuthNStore, licensing licensing.Licensing) (map[authtypes.AuthNProvider]authn.AuthN, error),
 	authzCallback func(context.Context, sqlstore.SQLStore, authz.Config, licensing.Licensing, []authz.OnBeforeRoleDelete) (factory.ProviderFactory[authz.AuthZ, authz.Config], error),
-	dashboardModuleCallback func(sqlstore.SQLStore, factory.ProviderSettings, analytics.Analytics, organization.Getter, queryparser.QueryParser, querier.Querier, licensing.Licensing, tag.Module) dashboard.Module,
+	dashboardModuleCallback func(sqlstore.SQLStore, factory.ProviderSettings, analytics.Analytics, organization.Getter, queryparser.QueryParser, querier.Querier, licensing.Licensing, tag.Module, dashboardtypes.SystemDashboardRegistry) dashboard.Module,
 	gatewayProviderFactory func(licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config],
 	auditorProviderFactories func(licensing.Licensing) factory.NamedMap[factory.ProviderFactory[auditor.Auditor, auditor.Config]],
 	meterReporterProviderFactories func(context.Context, factory.ProviderSettings, flagger.Flagger, licensing.Licensing, telemetrystore.TelemetryStore, retention.Getter, organization.Getter, zeus.Zeus) (factory.NamedMap[factory.ProviderFactory[meterreporter.Reporter, meterreporter.Config]], string),
@@ -440,8 +441,13 @@ func New(
 	// Initialize query parser (needed for dashboard module)
 	queryParser := queryparser.New(providerSettings)
 
-	// Initialize dashboard module
-	dashboard := dashboardModuleCallback(sqlstore, providerSettings, analytics, orgGetter, queryParser, querier, licensing, tagModule)
+	// Initialize dashboard module. The system dashboard registry is parsed here so
+	// a malformed embedded definition fails startup instead of a request.
+	systemDashboardRegistry, err := impldashboard.NewSystemDashboardRegistry()
+	if err != nil {
+		return nil, err
+	}
+	dashboard := dashboardModuleCallback(sqlstore, providerSettings, analytics, orgGetter, queryParser, querier, licensing, tagModule, systemDashboardRegistry)
 
 	// Initialize user getter
 	userGetter := impluser.NewGetter(userStore, userRoleStore, flagger)
@@ -610,6 +616,7 @@ func New(
 		factory.NewNamedService(factory.MustNewName("auditor"), auditor),
 		factory.NewNamedService(factory.MustNewName("meterreporter"), meterReporter, factory.MustNewName("licensing")),
 		factory.NewNamedService(factory.MustNewName("ruler"), rulerInstance),
+		factory.NewNamedService(factory.MustNewName("systemdashboard"), impldashboard.NewService(providerSettings, dashboard, orgGetter)),
 	)
 	if err != nil {
 		return nil, err

pkg/sqlmigration/119_add_license_tuples.go

@@ -1,159 +0,0 @@
-package sqlmigration
-
-import (
-	"context"
-	"database/sql"
-	"encoding/json"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/coretypes"
-	"github.com/oklog/ulid/v2"
-	"github.com/uptrace/bun"
-	"github.com/uptrace/bun/dialect"
-	"github.com/uptrace/bun/migrate"
-)
-
-type addLicenseTuples struct {
-	sqlstore sqlstore.SQLStore
-}
-
-func NewAddLicenseTuplesFactory(sqlstore sqlstore.SQLStore) factory.ProviderFactory[SQLMigration, Config] {
-	return factory.NewProviderFactory(factory.MustNewName("add_license_tuples"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
-		return &addLicenseTuples{sqlstore: sqlstore}, nil
-	})
-}
-
-func (migration *addLicenseTuples) Register(migrations *migrate.Migrations) error {
-	return migrations.Register(migration.Up, migration.Down)
-}
-
-func (migration *addLicenseTuples) Up(ctx context.Context, db *bun.DB) error {
-	tx, err := db.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = tx.Rollback() }()
-
-	var storeID string
-	err = tx.QueryRowContext(ctx, `SELECT id FROM store WHERE name = ? LIMIT 1`, "signoz").Scan(&storeID)
-	if err != nil {
-		return err
-	}
-
-	var orgIDs []string
-	err = tx.NewSelect().
-		Table("organizations").
-		Column("id").
-		Scan(ctx, &orgIDs)
-	if err != nil && err != sql.ErrNoRows {
-		return err
-	}
-
-	isPG := migration.sqlstore.BunDB().Dialect().Name() == dialect.PG
-
-	tuples := []migrationTuple{
-		{authtypes.SigNozAdminRoleName, "metaresource", "license", "create"},
-		{authtypes.SigNozAdminRoleName, "metaresource", "license", "read"},
-		{authtypes.SigNozAdminRoleName, "metaresource", "license", "update"},
-		{authtypes.SigNozAdminRoleName, "metaresource", "license", "delete"},
-		{authtypes.SigNozAdminRoleName, "metaresource", "license", "list"},
-	}
-
-	for _, orgID := range orgIDs {
-		for _, tuple := range tuples {
-			entropy := ulid.DefaultEntropy()
-			now := time.Now().UTC()
-			tupleID := ulid.MustNew(ulid.Timestamp(now), entropy).String()
-
-			objectID := "organization/" + orgID + "/" + tuple.objectName + "/*"
-			roleSubject := "organization/" + orgID + "/role/" + tuple.roleName
-
-			if isPG {
-				user := "role:" + roleSubject + "#assignee"
-				result, err := tx.ExecContext(ctx, `
-					INSERT INTO tuple (store, object_type, object_id, relation, _user, user_type, ulid, inserted_at)
-					VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-					ON CONFLICT (store, object_type, object_id, relation, _user) DO NOTHING`,
-					storeID, tuple.objectType, objectID, tuple.relation, user, "userset", tupleID, now,
-				)
-				if err != nil {
-					return err
-				}
-				rowsAffected, err := result.RowsAffected()
-				if err != nil {
-					return err
-				}
-				if rowsAffected == 0 {
-					continue
-				}
-				_, err = tx.ExecContext(ctx, `
-					INSERT INTO changelog (store, object_type, object_id, relation, _user, operation, ulid, inserted_at)
-					VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-					ON CONFLICT (store, ulid, object_type) DO NOTHING`,
-					storeID, tuple.objectType, objectID, tuple.relation, user, 0, tupleID, now,
-				)
-				if err != nil {
-					return err
-				}
-			} else {
-				result, err := tx.ExecContext(ctx, `
-					INSERT INTO tuple (store, object_type, object_id, relation, user_object_type, user_object_id, user_relation, user_type, ulid, inserted_at)
-					VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-					ON CONFLICT (store, object_type, object_id, relation, user_object_type, user_object_id, user_relation) DO NOTHING`,
-					storeID, tuple.objectType, objectID, tuple.relation, "role", roleSubject, "assignee", "userset", tupleID, now,
-				)
-				if err != nil {
-					return err
-				}
-				rowsAffected, err := result.RowsAffected()
-				if err != nil {
-					return err
-				}
-				if rowsAffected == 0 {
-					continue
-				}
-				_, err = tx.ExecContext(ctx, `
-					INSERT INTO changelog (store, object_type, object_id, relation, user_object_type, user_object_id, user_relation, operation, ulid, inserted_at)
-					VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-					ON CONFLICT (store, ulid, object_type) DO NOTHING`,
-					storeID, tuple.objectType, objectID, tuple.relation, "role", roleSubject, "assignee", 0, tupleID, now,
-				)
-				if err != nil {
-					return err
-				}
-			}
-		}
-	}
-
-	managedRoleGroups := make(map[string]string, len(coretypes.ManagedRoleToTransactions))
-	for roleName, transactions := range coretypes.ManagedRoleToTransactions {
-		data, err := json.Marshal(authtypes.NewTransactionGroupsFromTransactions(transactions))
-		if err != nil {
-			return err
-		}
-		managedRoleGroups[roleName] = string(data)
-	}
-
-	for _, orgID := range orgIDs {
-		for roleName, data := range managedRoleGroups {
-			if _, err := tx.NewUpdate().
-				Model(new(roles)).
-				Set("transaction_groups = ?", data).
-				Where("org_id = ?", orgID).
-				Where("type = ?", authtypes.RoleTypeManaged.StringValue()).
-				Where("name = ?", roleName).
-				Exec(ctx); err != nil {
-				return err
-			}
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (migration *addLicenseTuples) Down(context.Context, *bun.DB) error {
-	return nil
-}

pkg/sqlmigration/119_add_system_dashboard.go

@@ -0,0 +1,93 @@
+package sqlmigration
+
+import (
+	"context"
+
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/sqlschema"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/migrate"
+)
+
+type addSystemDashboard struct {
+	sqlstore  sqlstore.SQLStore
+	sqlschema sqlschema.SQLSchema
+}
+
+func NewAddSystemDashboardFactory(sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) factory.ProviderFactory[SQLMigration, Config] {
+	return factory.NewProviderFactory(
+		factory.MustNewName("add_system_dashboard"),
+		func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
+			return &addSystemDashboard{sqlstore: sqlstore, sqlschema: sqlschema}, nil
+		},
+	)
+}
+
+func (migration *addSystemDashboard) Register(migrations *migrate.Migrations) error {
+	return migrations.Register(migration.Up, migration.Down)
+}
+
+func (migration *addSystemDashboard) Up(ctx context.Context, db *bun.DB) error {
+	tx, err := db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = tx.Rollback() }()
+
+	sqls := migration.sqlschema.Operator().CreateTable(&sqlschema.Table{
+		Name: "system_dashboard",
+		Columns: []*sqlschema.Column{
+			{Name: "id", DataType: sqlschema.DataTypeText, Nullable: false},
+			{Name: "org_id", DataType: sqlschema.DataTypeText, Nullable: false},
+			{Name: "dashboard_id", DataType: sqlschema.DataTypeText, Nullable: false},
+			{Name: "name", DataType: sqlschema.DataTypeText, Nullable: false},
+			{Name: "version", DataType: sqlschema.DataTypeBigInt, Nullable: false},
+			{Name: "created_at", DataType: sqlschema.DataTypeTimestamp, Nullable: false},
+			{Name: "updated_at", DataType: sqlschema.DataTypeTimestamp, Nullable: false},
+		},
+		PrimaryKeyConstraint: &sqlschema.PrimaryKeyConstraint{
+			ColumnNames: []sqlschema.ColumnName{"id"},
+		},
+		ForeignKeyConstraints: []*sqlschema.ForeignKeyConstraint{
+			{
+				ReferencingColumnName: sqlschema.ColumnName("org_id"),
+				ReferencedTableName:   sqlschema.TableName("organizations"),
+				ReferencedColumnName:  sqlschema.ColumnName("id"),
+			},
+			{
+				ReferencingColumnName: sqlschema.ColumnName("dashboard_id"),
+				ReferencedTableName:   sqlschema.TableName("dashboard"),
+				ReferencedColumnName:  sqlschema.ColumnName("id"),
+			},
+		},
+	})
+
+	// (org_id, name) is what makes provisioning safe across replicas: the state
+	// row is written in the same transaction as the dashboard, so a losing racer
+	// rolls back its dashboard too.
+	sqls = append(sqls, migration.sqlschema.Operator().CreateIndex(
+		&sqlschema.UniqueIndex{
+			TableName:   "system_dashboard",
+			ColumnNames: []sqlschema.ColumnName{"org_id", "name"},
+		},
+	)...)
+	sqls = append(sqls, migration.sqlschema.Operator().CreateIndex(
+		&sqlschema.UniqueIndex{
+			TableName:   "system_dashboard",
+			ColumnNames: []sqlschema.ColumnName{"dashboard_id"},
+		},
+	)...)
+
+	for _, sql := range sqls {
+		if _, err := tx.ExecContext(ctx, string(sql)); err != nil {
+			return err
+		}
+	}
+
+	return tx.Commit()
+}
+
+func (migration *addSystemDashboard) Down(context.Context, *bun.DB) error {
+	return nil
+}

pkg/types/coretypes/registry_managed_role.go

@@ -64,10 +64,11 @@ var ManagedRoleToTransactions = map[string][]Transaction{
 		{Verb: VerbCreate, Object: *MustNewObject(ResourceRef{Type: TypeMetaResource, Kind: KindFactorPassword}, WildCardSelectorString)},
 		{Verb: VerbList, Object: *MustNewObject(ResourceRef{Type: TypeMetaResource, Kind: KindFactorPassword}, WildCardSelectorString)},
 		// license — admin only.
-		// Uniform LCRUD shape served by /api/v4/licenses: create = Activate,
-		// update = Refresh, read = Get (includes the key), list, delete (non-cloud
-		// licenses only). GET /api/v4/orgs/me/license is OpenAccess, so the read
-		// grant is not enforced there.
+		// Uniform LCRUD shape; actual ee routes are POST /api/v3/licenses (create
+		// = Activate), PUT /api/v3/licenses (update = Refresh), GET
+		// /api/v3/licenses/active (read; currently exposed as ViewAccess on the
+		// route side). delete and list are placeholders for shape parity, no
+		// route serves them today.
 		{Verb: VerbRead, Object: *MustNewObject(ResourceRef{Type: TypeMetaResource, Kind: KindLicense}, WildCardSelectorString)},
 		{Verb: VerbUpdate, Object: *MustNewObject(ResourceRef{Type: TypeMetaResource, Kind: KindLicense}, WildCardSelectorString)},
 		{Verb: VerbDelete, Object: *MustNewObject(ResourceRef{Type: TypeMetaResource, Kind: KindLicense}, WildCardSelectorString)},

pkg/types/dashboardtypes/perses_dashboard.go

@@ -25,6 +25,10 @@ const (
 	dashboardNameSuffixLen = 8
 )
 
+// SystemDashboardNamePrefix is reserved for dashboards SigNoz ships and owns. Generated
+// names never contain consecutive hyphens, so only a typed name can carry it — create rejects that.
+const SystemDashboardNamePrefix = "signoz---"
+
 const (
 	dashboardIconPathPrefix = "/assets/Icons/"
 	dashboardLogoPathPrefix = "/assets/Logos/"
@@ -75,8 +79,8 @@ type DashboardV2 struct {
 }
 
 func (d *DashboardV2) ErrIfNotMutable() error {
-	if d.Source == SourceIntegration {
-		return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardImmutable, "integration dashboards cannot be modified")
+	if d.Source != SourceUser {
+		return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardImmutable, "%s dashboards cannot be modified", d.Source)
 	}
 	return nil
 }
@@ -95,6 +99,11 @@ func (d *DashboardV2) Update(updatable UpdatableDashboardV2, updatedBy string, r
 	if err := d.ErrIfNotUpdatable(); err != nil {
 		return err
 	}
+	return d.UpdateUnsafe(updatable, updatedBy, resolvedTags)
+}
+
+// UpdateUnsafe applies the update without the source/lock gate. Intended for internal system callers.
+func (d *DashboardV2) UpdateUnsafe(updatable UpdatableDashboardV2, updatedBy string, resolvedTags []*tagtypes.Tag) error {
 	if updatable.Name != d.Name {
 		return errors.NewInvalidInputf(ErrCodeDashboardImmutable, "name is immutable; cannot change from %q to %q", d.Name, updatable.Name)
 	}
@@ -129,6 +138,13 @@ func (d *DashboardV2) LockUnlock(lock bool, isAdmin bool, updatedBy string) erro
 	return nil
 }
 
+func (d *DashboardV2) ErrIfNotSystem() error {
+	if d.Source != SourceSystem {
+		return errors.Newf(errors.TypeNotFound, ErrCodeDashboardNotFound, "dashboard %q is not a system dashboard", d.Name)
+	}
+	return nil
+}
+
 func (d *DashboardV2) ErrIfNotClonable() error {
 	if !d.Source.isClonable() {
 		return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardImmutable, "%s dashboards cannot be cloned", d.Source)
@@ -205,13 +221,21 @@ type PostableDashboardV2 struct {
 	Spec         DashboardSpec          `json:"spec" required:"true"`
 }
 
-func (postable PostableDashboardV2) NewDashboardV2(orgID valuer.UUID, createdBy string, source Source) *DashboardV2 {
+func (postable PostableDashboardV2) NewDashboardV2(orgID valuer.UUID, createdBy string, source Source) (*DashboardV2, error) {
 	now := time.Now()
 
 	name := postable.Name
 	if postable.GenerateName {
 		name = generateDashboardName(postable.Spec.Display.Name)
 	}
+	// Checked on the final name, here rather than in validateName, because only
+	// the constructor knows the source.
+	if source != SourceSystem && strings.HasPrefix(name, SystemDashboardNamePrefix) {
+		return nil, errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "name %q is invalid: the %q prefix is reserved for system dashboards", name, SystemDashboardNamePrefix)
+	}
+	if source == SourceSystem && !strings.HasPrefix(name, SystemDashboardNamePrefix) {
+		return nil, errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "name %q is invalid: system dashboard names must start with the %q prefix", name, SystemDashboardNamePrefix)
+	}
 
 	return &DashboardV2{
 		Identifiable:            types.Identifiable{ID: valuer.GenerateUUID()},
@@ -224,7 +248,7 @@ func (postable PostableDashboardV2) NewDashboardV2(orgID valuer.UUID, createdBy
 		Name:                    name,
 		Tags:                    tagtypes.NewTagsFromPostableTags(orgID, coretypes.KindDashboard, postable.Tags),
 		Spec:                    postable.Spec,
-	}
+	}, nil
 }
 
 func (p *PostableDashboardV2) UnmarshalJSON(data []byte) error {
@@ -365,6 +389,36 @@ func (d DashboardV2) ToGettableDashboardV2() GettableDashboardV2 {
 	}
 }
 
+// GettableSystemDashboard is the system-dashboard endpoint's response. System
+// dashboards are addressed by their stable definition name, so it carries no id.
+type GettableSystemDashboard struct {
+	types.TimeAuditable
+	types.UserAuditable
+
+	OrgID  valuer.UUID `json:"orgId" required:"true"`
+	Locked bool        `json:"locked" required:"true"`
+	Source Source      `json:"source" required:"true"`
+
+	DashboardV2MetadataBase
+	Name string                  `json:"name" required:"true"`
+	Tags []*tagtypes.GettableTag `json:"tags" required:"true"`
+	Spec DashboardSpec           `json:"spec" required:"true"`
+}
+
+func (d DashboardV2) ToGettableSystemDashboard() GettableSystemDashboard {
+	return GettableSystemDashboard{
+		TimeAuditable:           d.TimeAuditable,
+		UserAuditable:           d.UserAuditable,
+		OrgID:                   d.OrgID,
+		Locked:                  d.Locked,
+		Source:                  d.Source,
+		DashboardV2MetadataBase: d.DashboardV2MetadataBase,
+		Name:                    d.Name,
+		Tags:                    tagtypes.NewGettableTagsFromTags(d.Tags),
+		Spec:                    d.Spec,
+	}
+}
+
 // ════════════════════════════════════════════════════════════════════════
 // Storable
 // ════════════════════════════════════════════════════════════════════════

pkg/types/dashboardtypes/perses_dashboard_convertors_test.go

@@ -89,21 +89,25 @@ func TestPostableDashboardV2NewDashboardV2(t *testing.T) {
 	cases := []struct {
 		scenario       string
 		source         Source
+		name           string
 		expectedLocked bool
 	}{
 		{
 			scenario:       "user source is not locked",
 			source:         SourceUser,
+			name:           "my-dashboard",
 			expectedLocked: false,
 		},
 		{
 			scenario:       "system source is not locked",
 			source:         SourceSystem,
+			name:           SystemDashboardNamePrefix + "my-dashboard",
 			expectedLocked: false,
 		},
 		{
 			scenario:       "integration source is locked",
 			source:         SourceIntegration,
+			name:           "my-dashboard",
 			expectedLocked: true,
 		},
 	}
@@ -115,7 +119,7 @@ func TestPostableDashboardV2NewDashboardV2(t *testing.T) {
 					SchemaVersion: SchemaVersion,
 					Image:         "img",
 				},
-				Name: "my-dashboard",
+				Name: tc.name,
 				Tags: []tagtypes.PostableTag{
 					{Key: "team", Value: "platform"},
 					{Key: "env", Value: "prod"},
@@ -124,7 +128,8 @@ func TestPostableDashboardV2NewDashboardV2(t *testing.T) {
 			}
 
 			before := time.Now()
-			dashboard := postable.NewDashboardV2(orgID, "alice", tc.source)
+			dashboard, err := postable.NewDashboardV2(orgID, "alice", tc.source)
+			require.NoError(t, err)
 			after := time.Now()
 
 			require.NotNil(t, dashboard)
@@ -160,8 +165,10 @@ func TestPostableDashboardV2NewDashboardV2(t *testing.T) {
 			Spec:                    DashboardSpec{},
 		}
 
-		first := postable.NewDashboardV2(orgID, "alice", SourceUser)
-		second := postable.NewDashboardV2(orgID, "alice", SourceUser)
+		first, err := postable.NewDashboardV2(orgID, "alice", SourceUser)
+		require.NoError(t, err)
+		second, err := postable.NewDashboardV2(orgID, "alice", SourceUser)
+		require.NoError(t, err)
 		assert.NotEqual(t, first.ID, second.ID, "expected distinct UUIDs across invocations")
 	})
 
@@ -174,7 +181,8 @@ func TestPostableDashboardV2NewDashboardV2(t *testing.T) {
 			},
 		}
 
-		dashboard := postable.NewDashboardV2(orgID, "alice", SourceUser)
+		dashboard, err := postable.NewDashboardV2(orgID, "alice", SourceUser)
+		require.NoError(t, err)
 		assert.True(t, strings.HasPrefix(dashboard.Name, "my-dashboard-"), "expected slug prefix, got %q", dashboard.Name)
 		assert.Len(t, dashboard.Name, len("my-dashboard-")+dashboardNameSuffixLen)
 	})

pkg/types/dashboardtypes/perses_dashboard_patch_test.go

@@ -109,7 +109,8 @@ func TestPatchableDashboardV2_Apply(t *testing.T) {
 	var p PostableDashboardV2
 	require.NoError(t, json.Unmarshal([]byte(basePostableJSON), &p), "base postable JSON must validate")
 	testOrgID := valuer.GenerateUUID()
-	base := p.NewDashboardV2(testOrgID, "somecreatedthisiguess@signoz.io", SourceUser)
+	base, err := p.NewDashboardV2(testOrgID, "somecreatedthisiguess@signoz.io", SourceUser)
+	require.NoError(t, err)
 	base.Tags = []*tagtypes.Tag{
 		{Key: "team", Value: "alpha"},
 		{Key: "env", Value: "prod"},

pkg/types/dashboardtypes/perses_dashboard_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/perses/spec/go/dashboard"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -1928,3 +1929,37 @@ func TestEnsureSingleExpressionAggregation(t *testing.T) {
 		})
 	}
 }
+
+// Guards the constant: a prefixed name must stay a valid DNS-1123 label.
+func TestSystemDashboardNamePrefix(t *testing.T) {
+	require.NoError(t, validateDashboardName(SystemDashboardNamePrefix+"ai-o11y-overview"))
+}
+
+func TestNewDashboardV2RejectsReservedName(t *testing.T) {
+	testCases := []struct {
+		description string
+		name        string
+		source      Source
+		errContains string
+	}{
+		{description: "reserved name for a system dashboard", name: SystemDashboardNamePrefix + "overview", source: SourceSystem},
+		{description: "reserved name for a user dashboard", name: SystemDashboardNamePrefix + "overview", source: SourceUser, errContains: "reserved for system dashboards"},
+		{description: "reserved name for an integration dashboard", name: SystemDashboardNamePrefix + "overview", source: SourceIntegration, errContains: "reserved for system dashboards"},
+		{description: "unprefixed name for a system dashboard", name: "overview", source: SourceSystem, errContains: "must start with"},
+		{description: "ordinary name for a user dashboard", name: "overview", source: SourceUser},
+		{description: "fewer hyphens than the prefix for a user dashboard", name: "signoz--overview", source: SourceUser},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.description, func(t *testing.T) {
+			postable := PostableDashboardV2{Name: testCase.name}
+			_, err := postable.NewDashboardV2(valuer.GenerateUUID(), "user@signoz.io", testCase.source)
+			if testCase.errContains != "" {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), testCase.errContains)
+				return
+			}
+			require.NoError(t, err)
+		})
+	}
+}

pkg/types/dashboardtypes/store.go

@@ -13,6 +13,9 @@ type Store interface {
 
 	Get(context.Context, valuer.UUID, valuer.UUID) (*StorableDashboard, error)
 
+	// GetByName resolves a dashboard by its per-org unique name.
+	GetByName(ctx context.Context, orgID valuer.UUID, name string) (*StorableDashboard, error)
+
 	GetPublic(context.Context, string) (*StorablePublicDashboard, error)
 
 	GetDashboardByOrgsAndPublicID(context.Context, []string, string) (*StorableDashboard, error)
@@ -72,4 +75,13 @@ type Store interface {
 	UpdateDashboardView(ctx context.Context, view *DashboardView) error
 
 	DeleteDashboardView(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
+
+	// ════════════════════════════════════════════════════════════════════════
+	// System dashboard methods
+	// ════════════════════════════════════════════════════════════════════════
+	CreateSystemDashboard(ctx context.Context, storable *StorableSystemDashboard) error
+
+	GetSystemDashboard(ctx context.Context, orgID valuer.UUID, name string) (*StorableSystemDashboard, error)
+
+	UpdateSystemDashboardVersion(ctx context.Context, orgID valuer.UUID, name string, version int) error
 }

pkg/types/dashboardtypes/system_dashboard.go

@@ -0,0 +1,45 @@
+package dashboardtypes
+
+import (
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/uptrace/bun"
+)
+
+var (
+	ErrCodeSystemDashboardNotFound           = errors.MustNewCode("system_dashboard_not_found")
+	ErrCodeSystemDashboardDefinitionInvalid  = errors.MustNewCode("system_dashboard_definition_invalid")
+	ErrCodeSystemDashboardAlreadyProvisioned = errors.MustNewCode("system_dashboard_already_provisioned")
+)
+
+// ProvisionerIdentity is stamped into created_by/updated_by by the reconciler.
+const ProvisionerIdentity = "signoz"
+
+// StorableSystemDashboard records the shipped version each org's copy of a system
+// dashboard was last provisioned at. That version is the only thing the dashboard
+// row cannot answer, since the binary only embeds the latest definition.
+type StorableSystemDashboard struct {
+	bun.BaseModel `bun:"table:system_dashboard"`
+
+	types.Identifiable
+	types.TimeAuditable
+	OrgID       valuer.UUID `bun:"org_id,type:text,notnull"`
+	DashboardID valuer.UUID `bun:"dashboard_id,type:text,notnull"`
+	Name        string      `bun:"name,type:text,notnull"`
+	Version     int         `bun:"version,notnull"`
+}
+
+func NewStorableSystemDashboard(orgID valuer.UUID, dashboardID valuer.UUID, name string, version int) *StorableSystemDashboard {
+	now := time.Now()
+	return &StorableSystemDashboard{
+		Identifiable:  types.Identifiable{ID: valuer.GenerateUUID()},
+		TimeAuditable: types.TimeAuditable{CreatedAt: now, UpdatedAt: now},
+		OrgID:         orgID,
+		DashboardID:   dashboardID,
+		Name:          name,
+		Version:       version,
+	}
+}

pkg/types/dashboardtypes/system_dashboard_definition.go

@@ -0,0 +1,95 @@
+package dashboardtypes
+
+import (
+	"bytes"
+	"encoding/json"
+	"slices"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+)
+
+// SystemDashboardDefinition is one shipped system dashboard. Version is bumped on
+// every content change and drives upgrade detection; the name is the stable key
+// and never changes.
+type SystemDashboardDefinition struct {
+	Version   int                 `json:"version"`
+	Dashboard PostableDashboardV2 `json:"definition"`
+}
+
+func (definition SystemDashboardDefinition) Name() string {
+	return definition.Dashboard.Name
+}
+
+func NewSystemDashboardDefinition(raw []byte) (SystemDashboardDefinition, error) {
+	decoder := json.NewDecoder(bytes.NewReader(raw))
+	decoder.DisallowUnknownFields()
+
+	var definition SystemDashboardDefinition
+	if err := decoder.Decode(&definition); err != nil {
+		return SystemDashboardDefinition{}, errors.WrapInvalidInputf(err, ErrCodeSystemDashboardDefinitionInvalid, "%s", err.Error())
+	}
+	if err := definition.validate(); err != nil {
+		return SystemDashboardDefinition{}, err
+	}
+
+	return definition, nil
+}
+
+func (definition SystemDashboardDefinition) validate() error {
+	if definition.Version < 1 {
+		return errors.NewInvalidInputf(ErrCodeSystemDashboardDefinitionInvalid, "version must be at least 1, got %d", definition.Version)
+	}
+	if !strings.HasPrefix(definition.Name(), SystemDashboardNamePrefix) {
+		return errors.NewInvalidInputf(ErrCodeSystemDashboardDefinitionInvalid, "name %q must start with %q", definition.Name(), SystemDashboardNamePrefix)
+	}
+	if definition.Dashboard.GenerateName {
+		return errors.NewInvalidInputf(ErrCodeSystemDashboardDefinitionInvalid, "%s: generateName is not allowed, the name is the stable key", definition.Name())
+	}
+
+	return nil
+}
+
+// ToUpdatable is how an upgrade re-applies a definition onto an existing row:
+// everything but the dashboard's identity comes from the shipped definition.
+func (definition SystemDashboardDefinition) ToUpdatable() UpdatableDashboardV2 {
+	return UpdatableDashboardV2{
+		DashboardV2MetadataBase: definition.Dashboard.DashboardV2MetadataBase,
+		Name:                    definition.Dashboard.Name,
+		Tags:                    definition.Dashboard.Tags,
+		Spec:                    definition.Dashboard.Spec,
+	}
+}
+
+// SystemDashboardRegistry holds every definition embedded in the binary, keyed by name.
+type SystemDashboardRegistry struct {
+	definitions map[string]SystemDashboardDefinition
+}
+
+func NewSystemDashboardRegistry(definitions []SystemDashboardDefinition) (SystemDashboardRegistry, error) {
+	byName := make(map[string]SystemDashboardDefinition, len(definitions))
+	for _, definition := range definitions {
+		if _, duplicate := byName[definition.Name()]; duplicate {
+			return SystemDashboardRegistry{}, errors.NewInvalidInputf(ErrCodeSystemDashboardDefinitionInvalid, "duplicate system dashboard name %q", definition.Name())
+		}
+		byName[definition.Name()] = definition
+	}
+
+	return SystemDashboardRegistry{definitions: byName}, nil
+}
+
+func (registry SystemDashboardRegistry) Get(name string) (SystemDashboardDefinition, bool) {
+	definition, ok := registry.definitions[name]
+	return definition, ok
+}
+
+// List returns the definitions sorted by name so provisioning order is stable.
+func (registry SystemDashboardRegistry) List() []SystemDashboardDefinition {
+	definitions := make([]SystemDashboardDefinition, 0, len(registry.definitions))
+	for _, definition := range registry.definitions {
+		definitions = append(definitions, definition)
+	}
+	slices.SortFunc(definitions, func(a, b SystemDashboardDefinition) int { return strings.Compare(a.Name(), b.Name()) })
+
+	return definitions
+}

pkg/types/licensetypes/license.go

@@ -3,19 +3,15 @@ package licensetypes
 import (
 	"context"
 	"encoding/json"
+	"reflect"
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/zeustypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/uptrace/bun"
 )
 
-var (
-	ErrCodeCloudLicenseOperationUnsupported = errors.MustNewCode("cloud_license_operation_unsupported")
-)
-
 type StorableLicense struct {
 	bun.BaseModel `bun:"table:license"`
 
@@ -32,12 +28,10 @@ type License struct {
 	ID              valuer.UUID
 	Key             string
 	Data            map[string]interface{}
-	Plan            LicensePlan
-	EventQueue      LicenseEventQueue
+	PlanName        valuer.String
 	Features        []*Feature
 	Status          valuer.String
-	State           valuer.String
-	Platform        valuer.String
+	State           string
 	FreeUntil       time.Time
 	ValidFrom       int64
 	ValidUntil      int64
@@ -47,47 +41,28 @@ type License struct {
 	OrganizationID  valuer.UUID
 }
 
-type LicensePlan struct {
-	ID          valuer.UUID   `json:"id" required:"true"`
-	Name        valuer.String `json:"name" required:"true"`
-	Description string        `json:"description" required:"true"`
-	IsActive    bool          `json:"isActive" required:"true"`
-	CreatedAt   time.Time     `json:"createdAt" required:"true"`
-	UpdatedAt   time.Time     `json:"updatedAt" required:"true"`
-}
-
-type LicenseEventQueue struct {
-	Event       valuer.String `json:"event" required:"true"`
-	Status      valuer.String `json:"status" required:"true"`
-	ScheduledAt time.Time     `json:"scheduledAt" required:"true"`
-	CreatedAt   time.Time     `json:"createdAt" required:"true"`
-	UpdatedAt   time.Time     `json:"updatedAt" required:"true"`
-}
-
-type GettableLicense struct {
-	ID         valuer.UUID       `json:"id" required:"true"`
-	ValidFrom  int64             `json:"validFrom" required:"true"`
-	ValidUntil int64             `json:"validUntil" required:"true"`
-	Status     valuer.String     `json:"status" required:"true"`
-	State      valuer.String     `json:"state" required:"true"`
-	Platform   valuer.String     `json:"platform" required:"true"`
-	FreeUntil  time.Time         `json:"freeUntil" required:"true"`
-	CreatedAt  time.Time         `json:"createdAt" required:"true"`
-	UpdatedAt  time.Time         `json:"updatedAt" required:"true"`
-	Plan       LicensePlan       `json:"plan" required:"true"`
-	Features   []*Feature        `json:"features" required:"true"`
-	EventQueue LicenseEventQueue `json:"eventQueue" required:"true"`
-}
-
-type GettableLicenseWithKey struct {
-	GettableLicense
-	Key string `json:"key" required:"true"`
-}
+type GettableLicense map[string]any
 
 type PostableLicense struct {
 	Key string `json:"key"`
 }
 
+func NewStorableLicense(ID valuer.UUID, key string, data map[string]any, createdAt, updatedAt, lastValidatedAt time.Time, organizationID valuer.UUID) *StorableLicense {
+	return &StorableLicense{
+		Identifiable: types.Identifiable{
+			ID: ID,
+		},
+		TimeAuditable: types.TimeAuditable{
+			CreatedAt: createdAt,
+			UpdatedAt: updatedAt,
+		},
+		Key:             key,
+		Data:            data,
+		LastValidatedAt: lastValidatedAt,
+		OrgID:           organizationID,
+	}
+}
+
 func NewStorableLicenseFromLicense(license *License) *StorableLicense {
 	return &StorableLicense{
 		Identifiable: types.Identifiable{
@@ -131,201 +106,263 @@ func GetActiveLicenseFromStorableLicenses(storableLicenses []*StorableLicense, o
 	return activeLicense, nil
 }
 
-func NewLicense(zeusLicense *zeustypes.License, organizationID valuer.UUID) (*License, error) {
-	if zeusLicense.ID.IsZero() {
-		return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "license id is missing")
+func extractKeyFromMapStringInterface[T any](data map[string]interface{}, key string) (T, error) {
+	var zeroValue T
+	if val, ok := data[key]; ok {
+		if value, ok := val.(T); ok {
+			return value, nil
+		}
+		return zeroValue, errors.NewInvalidInputf(errors.CodeInvalidInput, "%s key is not a valid %s", key, reflect.TypeOf(zeroValue))
 	}
-
-	if zeusLicense.Key == "" {
-		return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "license key is missing")
-	}
-
-	planName, status, err := newPlanNameAndStatusFromZeusLicense(zeusLicense)
-	if err != nil {
-		return nil, err
-	}
-
-	features := newMergedFeatures(planName, zeusLicense.Features)
-
-	data, err := newDataFromZeusLicense(zeusLicense, features)
-	if err != nil {
-		return nil, err
-	}
-
-	return &License{
-		ID:              zeusLicense.ID,
-		Key:             zeusLicense.Key,
-		Data:            data,
-		Plan:            newLicensePlanFromZeusLicense(zeusLicense, planName),
-		EventQueue:      newLicenseEventQueueFromZeusLicense(zeusLicense),
-		Features:        features,
-		ValidFrom:       zeusLicense.ValidFrom,
-		ValidUntil:      zeusLicense.ValidUntil,
-		Status:          status,
-		State:           valuer.NewString(zeusLicense.State),
-		Platform:        valuer.NewString(zeusLicense.Platform),
-		FreeUntil:       zeusLicense.FreeUntil,
-		CreatedAt:       time.Now(),
-		UpdatedAt:       time.Now(),
-		LastValidatedAt: time.Now(),
-		OrganizationID:  organizationID,
-	}, nil
+	return zeroValue, errors.NewInvalidInputf(errors.CodeInvalidInput, "%s key is missing", key)
 }
 
-func NewLicenseFromStorableLicense(storableLicense *StorableLicense) (*License, error) {
-	zeusLicense, err := NewZeusLicenseFromData(storableLicense.Data)
+func NewLicense(data []byte, organizationID valuer.UUID) (*License, error) {
+	licenseData := map[string]any{}
+	err := json.Unmarshal(data, &licenseData)
 	if err != nil {
-		return nil, err
-	}
-
-	planName, status, err := newPlanNameAndStatusFromZeusLicense(zeusLicense)
-	if err != nil {
-		return nil, err
-	}
-
-	features := newMergedFeatures(planName, zeusLicense.Features)
-	storableLicense.Data["features"] = features
-
-	return &License{
-		ID:              storableLicense.ID,
-		Key:             storableLicense.Key,
-		Data:            storableLicense.Data,
-		Plan:            newLicensePlanFromZeusLicense(zeusLicense, planName),
-		EventQueue:      newLicenseEventQueueFromZeusLicense(zeusLicense),
-		Features:        features,
-		ValidFrom:       zeusLicense.ValidFrom,
-		ValidUntil:      zeusLicense.ValidUntil,
-		Status:          status,
-		State:           valuer.NewString(zeusLicense.State),
-		Platform:        valuer.NewString(zeusLicense.Platform),
-		FreeUntil:       zeusLicense.FreeUntil,
-		CreatedAt:       storableLicense.CreatedAt,
-		UpdatedAt:       storableLicense.UpdatedAt,
-		LastValidatedAt: storableLicense.LastValidatedAt,
-		OrganizationID:  storableLicense.OrgID,
-	}, nil
-}
-
-func NewZeusLicenseFromData(data map[string]any) (*zeustypes.License, error) {
-	dataBytes, err := json.Marshal(data)
-	if err != nil {
-		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal license data")
-	}
-
-	zeusLicense := new(zeustypes.License)
-	if err := json.Unmarshal(dataBytes, zeusLicense); err != nil {
 		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to unmarshal license data")
 	}
 
-	return zeusLicense, nil
-}
+	var features []*Feature
 
-func newPlanNameAndStatusFromZeusLicense(zeusLicense *zeustypes.License) (valuer.String, valuer.String, error) {
-	if zeusLicense.Status == "" {
-		return valuer.String{}, valuer.String{}, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "license status is missing")
+	// extract id from data
+	licenseIDStr, err := extractKeyFromMapStringInterface[string](licenseData, "id")
+	if err != nil {
+		return nil, err
+	}
+	licenseID, err := valuer.NewUUID(licenseIDStr)
+	if err != nil {
+		return nil, err
+	}
+	delete(licenseData, "id")
+
+	// extract key from data
+	licenseKey, err := extractKeyFromMapStringInterface[string](licenseData, "key")
+	if err != nil {
+		return nil, err
+	}
+	delete(licenseData, "key")
+
+	// extract status from data
+	statusStr, err := extractKeyFromMapStringInterface[string](licenseData, "status")
+	if err != nil {
+		return nil, err
+	}
+	status := valuer.NewString(statusStr)
+
+	planMap, err := extractKeyFromMapStringInterface[map[string]any](licenseData, "plan")
+	if err != nil {
+		return nil, err
 	}
 
-	if zeusLicense.Plan.Name == "" {
-		return valuer.String{}, valuer.String{}, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "license plan name is missing")
+	planNameStr, err := extractKeyFromMapStringInterface[string](planMap, "name")
+	if err != nil {
+		return nil, err
 	}
-
-	status := valuer.NewString(zeusLicense.Status)
-	planName := valuer.NewString(zeusLicense.Plan.Name)
+	planName := valuer.NewString(planNameStr)
 	// if license status is invalid then default it to basic
 	if status == LicenseStatusInvalid {
 		planName = PlanNameBasic
 	}
 
-	return planName, status, nil
-}
-
-func newLicensePlanFromZeusLicense(zeusLicense *zeustypes.License, planName valuer.String) LicensePlan {
-	return LicensePlan{
-		ID:          zeusLicense.Plan.ID,
-		Name:        planName,
-		Description: zeusLicense.Plan.Description,
-		IsActive:    zeusLicense.Plan.IsActive,
-		CreatedAt:   zeusLicense.Plan.CreatedAt,
-		UpdatedAt:   zeusLicense.Plan.UpdatedAt,
+	state, err := extractKeyFromMapStringInterface[string](licenseData, "state")
+	if err != nil {
+		state = ""
 	}
-}
 
-func newLicenseEventQueueFromZeusLicense(zeusLicense *zeustypes.License) LicenseEventQueue {
-	return LicenseEventQueue{
-		Event:       valuer.NewString(zeusLicense.EventQueue.Event),
-		Status:      valuer.NewString(zeusLicense.EventQueue.Status),
-		ScheduledAt: zeusLicense.EventQueue.ScheduledAt,
-		CreatedAt:   zeusLicense.EventQueue.CreatedAt,
-		UpdatedAt:   zeusLicense.EventQueue.UpdatedAt,
+	freeUntilStr, err := extractKeyFromMapStringInterface[string](licenseData, "free_until")
+	if err != nil {
+		freeUntilStr = ""
+	}
+
+	freeUntil, err := time.Parse(time.RFC3339, freeUntilStr)
+	if err != nil {
+		freeUntil = time.Time{}
+	}
+
+	featuresFromZeus := make([]*Feature, 0)
+	if _features, ok := licenseData["features"]; ok {
+		featuresData, err := json.Marshal(_features)
+		if err != nil {
+			return nil, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to marshal features data")
+		}
+
+		if err := json.Unmarshal(featuresData, &featuresFromZeus); err != nil {
+			return nil, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to unmarshal features data")
+		}
 	}
-}
 
-func newMergedFeatures(planName valuer.String, zeusFeatures []zeustypes.LicenseFeature) []*Feature {
-	features := make([]*Feature, 0)
 	switch planName {
 	case PlanNameEnterprise:
 		features = append(features, EnterprisePlan...)
+	case PlanNameBasic:
+		features = append(features, BasicPlan...)
 	default:
 		features = append(features, BasicPlan...)
 	}
 
-	for _, zeusFeature := range zeusFeatures {
-		feature := &Feature{
-			Name:       valuer.NewString(zeusFeature.Name),
-			Active:     zeusFeature.Active,
-			Usage:      zeusFeature.Usage,
-			UsageLimit: zeusFeature.UsageLimit,
-			Route:      zeusFeature.Route,
-		}
-
-		exists := false
-		for i, existingFeature := range features {
-			if existingFeature.Name == feature.Name {
-				features[i] = feature
-				exists = true
-				break
+	if len(featuresFromZeus) > 0 {
+		for _, feature := range featuresFromZeus {
+			exists := false
+			for i, existingFeature := range features {
+				if existingFeature.Name == feature.Name {
+					features[i] = feature // Replace existing feature
+					exists = true
+					break
+				}
+			}
+			if !exists {
+				features = append(features, feature) // Append if it doesn't exist
 			}
 		}
-		if !exists {
-			features = append(features, feature)
+	}
+	licenseData["features"] = features
+
+	_validFrom, err := extractKeyFromMapStringInterface[float64](licenseData, "valid_from")
+	if err != nil {
+		_validFrom = 0
+	}
+	validFrom := int64(_validFrom)
+
+	_validUntil, err := extractKeyFromMapStringInterface[float64](licenseData, "valid_until")
+	if err != nil {
+		_validUntil = 0
+	}
+	validUntil := int64(_validUntil)
+
+	return &License{
+		ID:              licenseID,
+		Key:             licenseKey,
+		Data:            licenseData,
+		PlanName:        planName,
+		Features:        features,
+		ValidFrom:       validFrom,
+		ValidUntil:      validUntil,
+		Status:          status,
+		State:           state,
+		FreeUntil:       freeUntil,
+		CreatedAt:       time.Now(),
+		UpdatedAt:       time.Now(),
+		LastValidatedAt: time.Now(),
+		OrganizationID:  organizationID,
+	}, nil
+
+}
+
+func NewLicenseFromStorableLicense(storableLicense *StorableLicense) (*License, error) {
+	var features []*Feature
+	// extract status from data
+	statusStr, err := extractKeyFromMapStringInterface[string](storableLicense.Data, "status")
+	if err != nil {
+		return nil, err
+	}
+	status := valuer.NewString(statusStr)
+
+	planMap, err := extractKeyFromMapStringInterface[map[string]any](storableLicense.Data, "plan")
+	if err != nil {
+		return nil, err
+	}
+
+	planNameStr, err := extractKeyFromMapStringInterface[string](planMap, "name")
+	if err != nil {
+		return nil, err
+	}
+	planName := valuer.NewString(planNameStr)
+	// if license status is invalid then default it to basic
+	if status == LicenseStatusInvalid {
+		planName = PlanNameBasic
+	}
+
+	featuresFromZeus := make([]*Feature, 0)
+	if _features, ok := storableLicense.Data["features"]; ok {
+		featuresData, err := json.Marshal(_features)
+		if err != nil {
+			return nil, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to marshal features data")
+		}
+
+		if err := json.Unmarshal(featuresData, &featuresFromZeus); err != nil {
+			return nil, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to unmarshal features data")
 		}
 	}
 
-	return features
-}
+	switch planName {
+	case PlanNameEnterprise:
+		features = append(features, EnterprisePlan...)
+	case PlanNameBasic:
+		features = append(features, BasicPlan...)
+	default:
+		features = append(features, BasicPlan...)
+	}
 
-func newDataFromZeusLicense(zeusLicense *zeustypes.License, features []*Feature) (map[string]any, error) {
-	dataBytes, err := json.Marshal(zeusLicense)
+	if len(featuresFromZeus) > 0 {
+		for _, feature := range featuresFromZeus {
+			exists := false
+			for i, existingFeature := range features {
+				if existingFeature.Name == feature.Name {
+					features[i] = feature // Replace existing feature
+					exists = true
+					break
+				}
+			}
+			if !exists {
+				features = append(features, feature) // Append if it doesn't exist
+			}
+		}
+	}
+	storableLicense.Data["features"] = features
+
+	_validFrom, err := extractKeyFromMapStringInterface[float64](storableLicense.Data, "valid_from")
 	if err != nil {
-		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal license data")
+		_validFrom = 0
+	}
+	validFrom := int64(_validFrom)
+
+	_validUntil, err := extractKeyFromMapStringInterface[float64](storableLicense.Data, "valid_until")
+	if err != nil {
+		_validUntil = 0
+	}
+	validUntil := int64(_validUntil)
+
+	state, err := extractKeyFromMapStringInterface[string](storableLicense.Data, "state")
+	if err != nil {
+		state = ""
 	}
 
-	data := map[string]any{}
-	if err := json.Unmarshal(dataBytes, &data); err != nil {
-		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to unmarshal license data")
+	freeUntilStr, err := extractKeyFromMapStringInterface[string](storableLicense.Data, "free_until")
+	if err != nil {
+		freeUntilStr = ""
 	}
 
-	delete(data, "id")
-	delete(data, "key")
-	data["features"] = features
-
-	return data, nil
-}
-
-// ErrIfCloud returns an error if the license is managed by SigNoz Cloud. The
-// caller should enrich the error with the specific operation using errors.WithAdditionalf.
-func (license *License) ErrIfCloud() error {
-	if license.Platform == LicensePlatformCloud {
-		return errors.New(errors.TypeInvalidInput, ErrCodeCloudLicenseOperationUnsupported, "this operation is not supported for licenses managed by SigNoz Cloud")
+	freeUntil, err := time.Parse(time.RFC3339, freeUntilStr)
+	if err != nil {
+		freeUntil = time.Time{}
 	}
-	return nil
+
+	return &License{
+		ID:              storableLicense.ID,
+		Key:             storableLicense.Key,
+		Data:            storableLicense.Data,
+		PlanName:        planName,
+		Features:        features,
+		ValidFrom:       validFrom,
+		ValidUntil:      validUntil,
+		Status:          status,
+		State:           state,
+		FreeUntil:       freeUntil,
+		CreatedAt:       storableLicense.CreatedAt,
+		UpdatedAt:       storableLicense.UpdatedAt,
+		LastValidatedAt: storableLicense.LastValidatedAt,
+		OrganizationID:  storableLicense.OrgID,
+	}, nil
+
 }
 
 func NewStatsFromLicense(license *License) map[string]any {
 	return map[string]any{
 		"license.id":              license.ID.StringValue(),
-		"license.plan.name":       license.Plan.Name.StringValue(),
-		"license.state.name":      license.State.StringValue(),
+		"license.plan.name":       license.PlanName.StringValue(),
+		"license.state.name":      license.State,
 		"license.free_until.time": license.FreeUntil.UTC(),
 	}
 }
@@ -334,8 +371,8 @@ func (license *License) UpdateFeatures(features []*Feature) {
 	license.Features = features
 }
 
-func (license *License) Update(zeusLicense *zeustypes.License) error {
-	updatedLicense, err := NewLicense(zeusLicense, license.OrganizationID)
+func (license *License) Update(data []byte) error {
+	updatedLicense, err := NewLicense(data, license.OrganizationID)
 	if err != nil {
 		return err
 	}
@@ -345,11 +382,8 @@ func (license *License) Update(zeusLicense *zeustypes.License) error {
 	license.Features = updatedLicense.Features
 	license.ID = updatedLicense.ID
 	license.Key = updatedLicense.Key
-	license.Plan = updatedLicense.Plan
-	license.EventQueue = updatedLicense.EventQueue
+	license.PlanName = updatedLicense.PlanName
 	license.Status = updatedLicense.Status
-	license.State = updatedLicense.State
-	license.Platform = updatedLicense.Platform
 	license.ValidFrom = updatedLicense.ValidFrom
 	license.ValidUntil = updatedLicense.ValidUntil
 	license.UpdatedAt = currentTime
@@ -358,28 +392,13 @@ func (license *License) Update(zeusLicense *zeustypes.License) error {
 	return nil
 }
 
-func NewGettableLicense(license *License) *GettableLicense {
-	return &GettableLicense{
-		ID:         license.ID,
-		ValidFrom:  license.ValidFrom,
-		ValidUntil: license.ValidUntil,
-		Status:     license.Status,
-		State:      license.State,
-		Platform:   license.Platform,
-		FreeUntil:  license.FreeUntil,
-		CreatedAt:  license.CreatedAt,
-		UpdatedAt:  license.UpdatedAt,
-		Plan:       license.Plan,
-		Features:   license.Features,
-		EventQueue: license.EventQueue,
-	}
-}
-
-func NewGettableLicenseWithKey(license *License) *GettableLicenseWithKey {
-	return &GettableLicenseWithKey{
-		GettableLicense: *NewGettableLicense(license),
-		Key:             license.Key,
+func NewGettableLicense(data map[string]any, key string) *GettableLicense {
+	gettableLicense := make(GettableLicense)
+	for k, v := range data {
+		gettableLicense[k] = v
 	}
+	gettableLicense["key"] = key
+	return &gettableLicense
 }
 
 func (p *PostableLicense) UnmarshalJSON(data []byte) error {
@@ -405,5 +424,4 @@ type Store interface {
 	Get(context.Context, valuer.UUID, valuer.UUID) (*StorableLicense, error)
 	GetAll(context.Context, valuer.UUID) ([]*StorableLicense, error)
 	Update(context.Context, valuer.UUID, *StorableLicense) error
-	Delete(context.Context, valuer.UUID, valuer.UUID) error
 }

pkg/types/licensetypes/license_test.go

@@ -1,135 +1,178 @@
 package licensetypes
 
 import (
-	"encoding/json"
 	"testing"
 	"time"
 
-	"github.com/SigNoz/signoz/pkg/types/zeustypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-func TestNewLicenseValidation(t *testing.T) {
-	organizationID := valuer.MustNewUUID("0196f794-ff30-7bee-a5f4-ef5ad315715e")
-
+func TestNewLicenseV3(t *testing.T) {
 	testCases := []struct {
-		name          string
-		data          string
-		errorContains string
+		name     string
+		data     []byte
+		pass     bool
+		expected *License
+		error    error
 	}{
 		{
-			name:          "missing license id",
-			data:          `{}`,
-			errorContains: "license id is missing",
+			name:  "Error for missing license id",
+			data:  []byte(`{}`),
+			pass:  false,
+			error: errors.New("id key is missing"),
 		},
 		{
-			name:          "missing license key",
-			data:          `{"id":"0196f794-ff30-7bee-a5f4-ef5ad315715e"}`,
-			errorContains: "license key is missing",
+			name:  "Error for license id not being a valid string",
+			data:  []byte(`{"id": 10}`),
+			pass:  false,
+			error: errors.New("id key is not a valid string"),
 		},
 		{
-			name:          "missing license status",
-			data:          `{"id":"0196f794-ff30-7bee-a5f4-ef5ad315715e","key":"does-not-matter"}`,
-			errorContains: "license status is missing",
+			name:  "Error for missing license key",
+			data:  []byte(`{"id":"0196f794-ff30-7bee-a5f4-ef5ad315715e"}`),
+			pass:  false,
+			error: errors.New("key key is missing"),
 		},
 		{
-			name:          "missing license plan name",
-			data:          `{"id":"0196f794-ff30-7bee-a5f4-ef5ad315715e","key":"does-not-matter","status":"ACTIVE","plan":{}}`,
-			errorContains: "license plan name is missing",
+			name:  "Error for invalid string license key",
+			data:  []byte(`{"id":"0196f794-ff30-7bee-a5f4-ef5ad315715e","key":10}`),
+			pass:  false,
+			error: errors.New("key key is not a valid string"),
+		},
+		{
+			name:  "Error for missing license status",
+			data:  []byte(`{"id":"0196f794-ff30-7bee-a5f4-ef5ad315715e", "key": "does-not-matter","category":"FREE"}`),
+			pass:  false,
+			error: errors.New("status key is missing"),
+		},
+		{
+			name:  "Error for invalid string license status",
+			data:  []byte(`{"id":"0196f794-ff30-7bee-a5f4-ef5ad315715e","key": "does-not-matter", "category":"FREE", "status":10}`),
+			pass:  false,
+			error: errors.New("status key is not a valid string"),
+		},
+		{
+			name:  "Error for missing license plan",
+			data:  []byte(`{"id":"0196f794-ff30-7bee-a5f4-ef5ad315715e","key":"does-not-matter-key","category":"FREE","status":"ACTIVE"}`),
+			pass:  false,
+			error: errors.New("plan key is missing"),
+		},
+		{
+			name:  "Error for invalid json license plan",
+			data:  []byte(`{"id":"0196f794-ff30-7bee-a5f4-ef5ad315715e","key":"does-not-matter-key","category":"FREE","status":"ACTIVE","plan":10}`),
+			pass:  false,
+			error: errors.New("plan key is not a valid map[string]interface {}"),
+		},
+		{
+			name:  "Error for invalid license plan",
+			data:  []byte(`{"id":"0196f794-ff30-7bee-a5f4-ef5ad315715e","key":"does-not-matter-key","category":"FREE","status":"ACTIVE","plan":{}}`),
+			pass:  false,
+			error: errors.New("name key is missing"),
+		},
+		{
+			name: "Parse the entire license properly",
+			data: []byte(`{"id":"0196f794-ff30-7bee-a5f4-ef5ad315715e","key":"does-not-matter-key","category":"FREE","status":"ACTIVE","plan":{"name":"ENTERPRISE"},"valid_from": 1730899309,"valid_until": -1,"state":"test","free_until":"2025-05-16T11:17:48.124202Z"}`),
+			pass: true,
+			expected: &License{
+				ID:  valuer.MustNewUUID("0196f794-ff30-7bee-a5f4-ef5ad315715e"),
+				Key: "does-not-matter-key",
+				Data: map[string]interface{}{
+					"plan": map[string]interface{}{
+						"name": "ENTERPRISE",
+					},
+					"category":    "FREE",
+					"status":      "ACTIVE",
+					"valid_from":  float64(1730899309),
+					"valid_until": float64(-1),
+					"state":       "test",
+					"free_until":  "2025-05-16T11:17:48.124202Z",
+				},
+				PlanName:       PlanNameEnterprise,
+				ValidFrom:      1730899309,
+				ValidUntil:     -1,
+				Status:         valuer.NewString("ACTIVE"),
+				State:          "test",
+				FreeUntil:      time.Date(2025, 5, 16, 11, 17, 48, 124202000, time.UTC),
+				Features:       make([]*Feature, 0),
+				OrganizationID: valuer.MustNewUUID("0196f794-ff30-7bee-a5f4-ef5ad315715e"),
+			},
+		},
+		{
+			name: "Fallback to basic plan if license status is invalid",
+			data: []byte(`{"id":"0196f794-ff30-7bee-a5f4-ef5ad315715e","key":"does-not-matter-key","category":"FREE","status":"INVALID","plan":{"name":"ENTERPRISE"},"valid_from": 1730899309,"valid_until": -1}`),
+			pass: true,
+			expected: &License{
+				ID:  valuer.MustNewUUID("0196f794-ff30-7bee-a5f4-ef5ad315715e"),
+				Key: "does-not-matter-key",
+				Data: map[string]interface{}{
+					"plan": map[string]interface{}{
+						"name": "ENTERPRISE",
+					},
+					"category":    "FREE",
+					"status":      "INVALID",
+					"valid_from":  float64(1730899309),
+					"valid_until": float64(-1),
+				},
+				PlanName:       PlanNameBasic,
+				ValidFrom:      1730899309,
+				ValidUntil:     -1,
+				Status:         valuer.NewString("INVALID"),
+				Features:       make([]*Feature, 0),
+				OrganizationID: valuer.MustNewUUID("0196f794-ff30-7bee-a5f4-ef5ad315715e"),
+			},
+		},
+		{
+			name: "fallback states for validFrom and validUntil",
+			data: []byte(`{"id":"0196f794-ff30-7bee-a5f4-ef5ad315715e","key":"does-not-matter-key","category":"FREE","status":"ACTIVE","plan":{"name":"ENTERPRISE"},"valid_from":1234.456,"valid_until":5678.567}`),
+			pass: true,
+			expected: &License{
+				ID:  valuer.MustNewUUID("0196f794-ff30-7bee-a5f4-ef5ad315715e"),
+				Key: "does-not-matter-key",
+				Data: map[string]interface{}{
+					"plan": map[string]interface{}{
+						"name": "ENTERPRISE",
+					},
+					"valid_from":  1234.456,
+					"valid_until": 5678.567,
+					"category":    "FREE",
+					"status":      "ACTIVE",
+				},
+				PlanName:        PlanNameEnterprise,
+				ValidFrom:       1234,
+				ValidUntil:      5678,
+				Status:          valuer.NewString("ACTIVE"),
+				Features:        make([]*Feature, 0),
+				CreatedAt:       time.Time{},
+				UpdatedAt:       time.Time{},
+				LastValidatedAt: time.Time{},
+				OrganizationID:  valuer.MustNewUUID("0196f794-ff30-7bee-a5f4-ef5ad315715e"),
+			},
 		},
 	}
 
 	for _, tc := range testCases {
-		zeusLicense := new(zeustypes.License)
-		require.NoError(t, json.Unmarshal([]byte(tc.data), zeusLicense), tc.name)
-
-		license, err := NewLicense(zeusLicense, organizationID)
-		require.Error(t, err, tc.name)
-		assert.ErrorContains(t, err, tc.errorContains, tc.name)
-		require.Nil(t, license, tc.name)
-	}
-}
-
-func TestNewLicense(t *testing.T) {
-	organizationID := valuer.MustNewUUID("0196f794-ff30-7bee-a5f4-ef5ad315715e")
-
-	zeusLicense := new(zeustypes.License)
-	require.NoError(t, json.Unmarshal([]byte(`{"id":"0196f794-ff30-7bee-a5f4-ef5ad315715e","key":"does-not-matter-key","status":"ACTIVE","state":"EVALUATING","platform":"SELF_HOSTED","plan":{"name":"ENTERPRISE"},"valid_from":1730899309,"valid_until":-1,"free_until":"2025-05-16T11:17:48.124202Z","features":[{"name":"sso","active":true,"usage":0,"usage_limit":-1,"route":""}],"event_queue":{"event":"DEFAULT","status":"SCHEDULED"}}`), zeusLicense))
-
-	license, err := NewLicense(zeusLicense, organizationID)
-	require.NoError(t, err)
-
-	assert.Equal(t, valuer.MustNewUUID("0196f794-ff30-7bee-a5f4-ef5ad315715e"), license.ID)
-	assert.Equal(t, "does-not-matter-key", license.Key)
-	assert.Equal(t, PlanNameEnterprise, license.Plan.Name)
-	assert.Equal(t, valuer.NewString("active"), license.Status)
-	assert.Equal(t, valuer.NewString("evaluating"), license.State)
-	assert.Equal(t, LicensePlatformSelfHosted, license.Platform)
-	assert.Equal(t, valuer.NewString("default"), license.EventQueue.Event)
-	assert.Equal(t, valuer.NewString("scheduled"), license.EventQueue.Status)
-	assert.Equal(t, int64(1730899309), license.ValidFrom)
-	assert.Equal(t, int64(-1), license.ValidUntil)
-	assert.Equal(t, time.Date(2025, 5, 16, 11, 17, 48, 124202000, time.UTC), license.FreeUntil)
-	assert.Equal(t, organizationID, license.OrganizationID)
-
-	ssoFeature := false
-	for _, feature := range license.Features {
-		if feature.Name == SSO {
-			ssoFeature = feature.Active
+		license, err := NewLicense(tc.data, valuer.MustNewUUID("0196f794-ff30-7bee-a5f4-ef5ad315715e"))
+		if license != nil {
+			license.Features = make([]*Feature, 0)
+			delete(license.Data, "features")
 		}
+
+		if tc.pass {
+			require.NoError(t, err)
+			require.NotNil(t, license)
+			// as the new license will pick the time.Now() value. doesn't make sense to compare them
+			license.CreatedAt = time.Time{}
+			license.UpdatedAt = time.Time{}
+			license.LastValidatedAt = time.Time{}
+			assert.Equal(t, tc.expected, license)
+		} else {
+			require.Error(t, err)
+			assert.EqualError(t, err, tc.error.Error())
+			require.Nil(t, license)
+		}
+
 	}
-	assert.True(t, ssoFeature)
-
-	assert.NotContains(t, license.Data, "id")
-	assert.NotContains(t, license.Data, "key")
-	assert.Equal(t, "ACTIVE", license.Data["status"])
-
-	gettableLicense := NewGettableLicense(license)
-	assert.Equal(t, license.ID, gettableLicense.ID)
-	assert.Equal(t, valuer.NewString("active"), gettableLicense.Status)
-	assert.Equal(t, LicensePlatformSelfHosted, gettableLicense.Platform)
-	assert.Equal(t, PlanNameEnterprise, gettableLicense.Plan.Name)
-
-	gettableLicenseWithKey := NewGettableLicenseWithKey(license)
-	assert.Equal(t, "does-not-matter-key", gettableLicenseWithKey.Key)
-}
-
-func TestNewLicenseFallsBackToBasicPlanOnInvalidStatus(t *testing.T) {
-	organizationID := valuer.MustNewUUID("0196f794-ff30-7bee-a5f4-ef5ad315715e")
-
-	zeusLicense := new(zeustypes.License)
-	require.NoError(t, json.Unmarshal([]byte(`{"id":"0196f794-ff30-7bee-a5f4-ef5ad315715e","key":"does-not-matter-key","status":"INVALID","plan":{"name":"ENTERPRISE"},"valid_from":1730899309,"valid_until":-1}`), zeusLicense))
-
-	license, err := NewLicense(zeusLicense, organizationID)
-	require.NoError(t, err)
-
-	assert.Equal(t, PlanNameBasic, license.Plan.Name)
-}
-
-func TestNewLicenseFromStorableLicenseRoundTrip(t *testing.T) {
-	organizationID := valuer.MustNewUUID("0196f794-ff30-7bee-a5f4-ef5ad315715e")
-
-	zeusLicense := new(zeustypes.License)
-	require.NoError(t, json.Unmarshal([]byte(`{"id":"0196f794-ff30-7bee-a5f4-ef5ad315715e","key":"does-not-matter-key","status":"ACTIVE","state":"EVALUATING","platform":"CLOUD","plan":{"name":"ENTERPRISE"},"valid_from":1730899309,"valid_until":-1}`), zeusLicense))
-
-	license, err := NewLicense(zeusLicense, organizationID)
-	require.NoError(t, err)
-
-	storableLicense := NewStorableLicenseFromLicense(license)
-
-	roundTrippedLicense, err := NewLicenseFromStorableLicense(storableLicense)
-	require.NoError(t, err)
-
-	assert.Equal(t, license.ID, roundTrippedLicense.ID)
-	assert.Equal(t, license.Key, roundTrippedLicense.Key)
-	assert.Equal(t, license.Plan.Name, roundTrippedLicense.Plan.Name)
-	assert.Equal(t, license.Status, roundTrippedLicense.Status)
-	assert.Equal(t, license.State, roundTrippedLicense.State)
-	assert.Equal(t, LicensePlatformCloud, roundTrippedLicense.Platform)
-	assert.Equal(t, license.ValidFrom, roundTrippedLicense.ValidFrom)
-	assert.Equal(t, license.ValidUntil, roundTrippedLicense.ValidUntil)
-
-	assert.ErrorContains(t, roundTrippedLicense.ErrIfCloud(), "not supported for licenses managed by SigNoz Cloud")
 }

pkg/types/licensetypes/plan.go

@@ -17,10 +17,6 @@ var (
 	// License State.
 	LicenseStatusInvalid = valuer.NewString("invalid")
 
-	// License Platform.
-	LicensePlatformCloud      = valuer.NewString("cloud")
-	LicensePlatformSelfHosted = valuer.NewString("self_hosted")
-
 	// Plan.
 	PlanNameEnterprise = valuer.NewString("enterprise")
 	PlanNameBasic      = valuer.NewString("basic")

pkg/types/zeustypes/license.go

@@ -1,49 +0,0 @@
-package zeustypes
-
-import (
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type LicenseFeature struct {
-	Name       string `json:"name"`
-	Active     bool   `json:"active"`
-	Usage      int64  `json:"usage"`
-	UsageLimit int64  `json:"usage_limit"`
-	Route      string `json:"route"`
-}
-
-type LicensePlan struct {
-	ID          valuer.UUID `json:"id"`
-	Name        string      `json:"name"`
-	Description string      `json:"description"`
-	IsActive    bool        `json:"is_active"`
-	CreatedAt   time.Time   `json:"created_at"`
-	UpdatedAt   time.Time   `json:"updated_at"`
-}
-
-type LicenseEventQueue struct {
-	Event       string    `json:"event"`
-	Status      string    `json:"status"`
-	ScheduledAt time.Time `json:"scheduled_at"`
-	CreatedAt   time.Time `json:"created_at"`
-	UpdatedAt   time.Time `json:"updated_at"`
-}
-
-type License struct {
-	ID         valuer.UUID       `json:"id"`
-	Key        string            `json:"key"`
-	ValidFrom  int64             `json:"valid_from"`
-	ValidUntil int64             `json:"valid_until"`
-	Status     string            `json:"status"`
-	State      string            `json:"state"`
-	Platform   string            `json:"platform"`
-	FreeUntil  time.Time         `json:"free_until"`
-	CreatedAt  time.Time         `json:"created_at"`
-	UpdatedAt  time.Time         `json:"updated_at"`
-	PlanID     valuer.UUID       `json:"plan_id"`
-	Plan       LicensePlan       `json:"plan"`
-	Features   []LicenseFeature  `json:"features"`
-	EventQueue LicenseEventQueue `json:"event_queue"`
-}

pkg/zeus/noopzeus/provider.go

@@ -21,7 +21,7 @@ func New(_ context.Context, _ factory.ProviderSettings, _ zeus.Config) (zeus.Zeu
 	return &provider{}, nil
 }
 
-func (provider *provider) GetLicense(_ context.Context, _ string) (*zeustypes.License, error) {
+func (provider *provider) GetLicense(_ context.Context, _ string) ([]byte, error) {
 	return nil, errors.New(errors.TypeUnsupported, zeus.ErrCodeUnsupported, "fetching license is not supported")
 }
 

pkg/zeus/zeus.go

@@ -15,7 +15,7 @@ var (
 
 type Zeus interface {
 	// Returns the license for the given key.
-	GetLicense(context.Context, string) (*zeustypes.License, error)
+	GetLicense(context.Context, string) ([]byte, error)
 
 	// Returns the checkout URL for the given license key.
 	GetCheckoutURL(context.Context, string, []byte) ([]byte, error)

tests/integration/tests/dashboard/07_system_dashboard.py

@@ -0,0 +1,192 @@
+from collections.abc import Callable
+from http import HTTPStatus
+
+import requests
+from sqlalchemy import sql
+
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
+from fixtures.dashboards import DASHBOARDS_BASE_URL, MAX_LIST_LIMIT
+from fixtures.types import Operation, SigNoz
+
+SYSTEM_BASE_URL = "/api/v2/dashboards/system"
+
+# Provisioned for every org by the reconciler; the path segment is the bare
+# definition name, the stored name carries the reserved prefix.
+SYSTEM_DASHBOARD_NAME = "ai-o11y-overview"
+SYSTEM_DASHBOARD_PREFIX = "signoz---"
+
+
+def test_get_system_dashboard(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(f"{SYSTEM_BASE_URL}/{SYSTEM_DASHBOARD_NAME}"),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.OK, response.text
+    dashboard = response.json()["data"]
+    assert dashboard["name"] == SYSTEM_DASHBOARD_PREFIX + SYSTEM_DASHBOARD_NAME
+    assert dashboard["source"] == "system"
+    assert dashboard["createdBy"] == "signoz"
+    assert dashboard["schemaVersion"] == "v6"
+    assert "id" not in dashboard
+
+
+def test_get_system_dashboard_rejects_prefixed_name(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(f"{SYSTEM_BASE_URL}/{SYSTEM_DASHBOARD_PREFIX}{SYSTEM_DASHBOARD_NAME}"),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert "must not carry" in response.json()["error"]["message"]
+
+
+def test_get_missing_system_dashboard_returns_not_found(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(f"{SYSTEM_BASE_URL}/no-such-dashboard"),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.NOT_FOUND, response.text
+
+
+def test_system_dashboard_hidden_from_list_but_gettable_by_id(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    # The API never exposes a system dashboard's id; read it from the state row.
+    with signoz.sqlstore.conn.connect() as conn:
+        dashboard_id = conn.execute(
+            sql.text("SELECT dashboard_id FROM system_dashboard WHERE name = :name"),
+            {"name": SYSTEM_DASHBOARD_PREFIX + SYSTEM_DASHBOARD_NAME},
+        ).scalar_one()
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(f"{DASHBOARDS_BASE_URL}?limit={MAX_LIST_LIMIT}"),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    listed = response.json()["data"]["dashboards"] or []
+    assert all(dashboard["source"] != "system" for dashboard in listed)
+    assert all(dashboard["id"] != dashboard_id for dashboard in listed)
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(f"{DASHBOARDS_BASE_URL}/{dashboard_id}"),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    assert response.json()["data"]["source"] == "system"
+
+
+def test_system_dashboard_is_immutable(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(f"{SYSTEM_BASE_URL}/{SYSTEM_DASHBOARD_NAME}"),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    dashboard = response.json()["data"]
+
+    with signoz.sqlstore.conn.connect() as conn:
+        dashboard_id = conn.execute(
+            sql.text("SELECT dashboard_id FROM system_dashboard WHERE name = :name"),
+            {"name": SYSTEM_DASHBOARD_PREFIX + SYSTEM_DASHBOARD_NAME},
+        ).scalar_one()
+
+    response = requests.put(
+        signoz.self.host_configs["8080"].get(f"{DASHBOARDS_BASE_URL}/{dashboard_id}"),
+        json={
+            "schemaVersion": dashboard["schemaVersion"],
+            "name": dashboard["name"],
+            "tags": [],
+            "spec": dashboard["spec"],
+        },
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json()["error"]["code"] == "dashboard_immutable"
+
+    response = requests.delete(
+        signoz.self.host_configs["8080"].get(f"{DASHBOARDS_BASE_URL}/{dashboard_id}"),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json()["error"]["code"] == "dashboard_immutable"
+
+    response = requests.put(
+        signoz.self.host_configs["8080"].get(f"{DASHBOARDS_BASE_URL}/{dashboard_id}/lock"),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json()["error"]["code"] == "dashboard_immutable"
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(f"{DASHBOARDS_BASE_URL}/{dashboard_id}/clone"),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert response.json()["error"]["code"] == "dashboard_immutable"
+
+
+def test_create_rejects_reserved_prefix_name(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(DASHBOARDS_BASE_URL),
+        json={
+            "schemaVersion": "v6",
+            "name": f"{SYSTEM_DASHBOARD_PREFIX}custom",
+            "tags": [],
+            "spec": {
+                "display": {"name": "Custom"},
+                "variables": [],
+                "panels": {},
+                "layouts": [],
+            },
+        },
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    assert "reserved for system dashboards" in response.json()["error"]["message"]