proto: prototype notes for review

Assisted-by: Claude Fable 5

.github/workflows/goci.yaml

@@ -67,7 +67,7 @@ jobs:
         with:
           go-version: "1.24"
       - name: check-semconv-generated-files
-        run: go run ./scripts/semconv -check
+        run: make semconv-check
   build:
     if: |
       github.event_name == 'merge_group' ||

.github/workflows/integrationci.yaml

@@ -58,7 +58,6 @@ jobs:
           - querierai
           - rawexportdata
           - promqlconformance
-          - promapiconformance
           - querierauthz
           - role
           - rootuser

Makefile

@@ -237,6 +237,10 @@ py-clean: ## Clear all pycache and pytest cache from tests directory recursively
 semconv-generate: ## Regenerate semantic-convention families for Go and TypeScript
 	@go run ./scripts/semconv
 
+.PHONY: semconv-check
+semconv-check: ## Fail if the generated semantic-convention files are stale
+	@go run ./scripts/semconv -check
+
 .PHONY: gen-mocks
 gen-mocks:
 	@echo ">> Generating mocks"

cmd/authz.go

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

cmd/community/server.go

@@ -46,7 +46,6 @@ 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"
@@ -104,8 +103,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, systemDashboardRegistry dashboardtypes.SystemDashboardRegistry) dashboard.Module {
-			return impldashboard.NewModule(impldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, tagModule, systemDashboardRegistry)
+		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(_ licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config] {
 			return noopgateway.NewProviderFactory()

cmd/enterprise/server.go

@@ -63,7 +63,6 @@ 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"
@@ -137,8 +136,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, systemDashboardRegistry dashboardtypes.SystemDashboardRegistry) dashboard.Module {
-			return impldashboard.NewModule(pkgimpldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, querier, licensing, tagModule, systemDashboardRegistry)
+		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(licensing licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config] {
 			return httpgateway.NewProviderFactory(licensing)

docs/contributing/prometheus.md

@@ -299,11 +299,8 @@ substituted. One subtlety makes it exact: we write stale markers at absent
 grid points. Without them, the engine's lookback would resurrect a point
 from up to `lookback` earlier. The marker encodes "absent here" the way the
 engine itself encodes it. Units evaluate concurrently. Each unit is one
-grid statement: the group-key join resolves the matchers, and the samples
-primary key takes the metric name straight from the selector. Only a
-selector without a static `__name__` runs the series lookup first, to learn
-the concrete metric names. A step of 0 is an instant query: a single
-evaluation at `end`.
+series lookup plus one grid statement. A step of 0 is an instant query: a
+single evaluation at `end`.
 
 A note on the window sliver: when the window is narrower than the step, the
 grid windows cover only `window/step` of the timeline. A sample in a gap
@@ -318,9 +315,8 @@ selectors and `last_over_time` transpile at window < step too.
 
 ## Series lookup
 
-The engine path resolves matchers once per selector (`selectSeries`); the
-transpiled path builds the same conditions into its group-key join. Both
-read the same tables. The series tables hold one row per (fingerprint, bucket)
+Both paths resolve matchers the same way, once per selector
+(`selectSeries`). The series tables hold one row per (fingerprint, bucket)
 at 1h/6h/1d/1w granularities. The shared schema package
 (`pkg/telemetryschema/metricstelemetryschema`) picks the table whose bucket
 fits the window. It rounds the window start down to the bucket boundary, so

docs/tree-model-prototype.md

@@ -0,0 +1,100 @@
+# Tree-model prototype (proto/tree-model)
+
+A local prototype of the proposed end-state architecture, built on
+`feat/semconv-phase2-signals` with byte-parity as the acceptance bar: every
+golden and every integration case must produce identical SQL. The prototype
+exists to let a reviewer judge the model empirically — how small the generic
+core really is, how large the per-signal residue really is, and where the
+line between them falls.
+
+## What became generic
+
+### The term compiler — `pkg/querybuilder/term.go`
+
+`CompileTerm` is the flow of one filter term, written once:
+
+1. resolve the evidence (`ResolveLogicalFields`, ambiguity warning),
+2. amend it with intrinsic storage (`TermSchema.AmendEvidence`),
+3. synthesize when it is empty (`TermSchema.Synthesize`),
+4. apply the resource-filter policy (`SkipResourcePolicy`),
+5. compile every field (`TermSchema.CompileField`), collecting warnings in
+   a fixed order.
+
+Six condition builders became delegates to it: traces, logs, metrics, audit,
+rule state history, and the resource filter. Each keeps a term-level
+intercept in front where one exists (`search()` on logs, the function-operator
+reject or skip), and implements the three `TermSchema` methods. The six
+hand-rolled copies of the flow are gone; a change to the flow — the order of
+warnings, the synthesized-exemption of the resource drop — now has one home.
+
+`CompileFieldWithSharedOperators` is the canonical `CompileField`: the shared
+operator switch (`LogicalFamilyCondition`) over the merged or single value
+expression, with the default exists guard for positive operators. Traces uses
+it for every field; logs and metrics use it for families.
+
+### The coerced column renderer — `pkg/querybuilder/column.go`
+
+`RenderCoercedColumn` renders resolved fields for group-by, order, and
+aggregation arguments: every field exists-guarded and coerced in one
+`multiIf`, with the NULL group preserved. Traces and logs delegate their
+coerced modes to it through three leaf questions (`ColumnSchema`):
+
+- `RawRead` — the uncoerced read of one field (logs overrides the legacy
+  body path),
+- `Uncoerced` — the coercion exemption (traces time columns, logs legacy
+  body reads),
+- `BareCandidate` — the fields that cannot sit inside `multiIf` (arrays).
+
+## What stayed per-signal, and why
+
+- **The single-key operator switches.** Metrics coerces collisions with its
+  own casts (`toFloat64OrNull`, labels-as-String), logs carries the body
+  machinery and the body-column index forms, audit and rule state history
+  have their own switches. Unifying them changes SQL, so byte-parity forbids
+  it here. This is the real distance to "one operator switch": it exists for
+  families today, and extending it to singles is a re-pinning exercise, not a
+  refactor.
+- **The resource-filter compile.** Index hints are woven into every operator
+  case with per-operator polarity rules; the whole field compile stays its
+  own (`CompileField` overrides wholesale).
+- **The raw-select tails.** Traces and logs raw-select shapes differ in more
+  dimensions than they share (guard tests, stringification, collision
+  application), so `ColumnExpressionFor`'s Unspecified mode keeps its
+  per-signal tails. A generic raw renderer would need more knobs than it
+  removes lines.
+- **The column resolution orders.** Which candidates a column stage sees —
+  the storage probe, the metadata lookups, the swap/append of resolved
+  spellings — keeps its pinned per-signal order in the mappers. Moving it
+  into a generic `Resolve` is the model-B step proper, and it needs the
+  stage-aware synthesis asymmetry (filters synthesize by operand, columns
+  do not) carried as data.
+- **Metadata.** Its merged-value semantics bind query parameters inside
+  presence guards, which the arg-free `ExistsFor` contract cannot express.
+  Untouched, as declared.
+
+## The review round (applied)
+
+- The rule-state-history operator forms are pinned in the commit BEFORE the
+  port (it had no tests and diverges most: IN binds the whole list to one
+  placeholder, exists renders two ways), so the port proves parity.
+- Audit refuses families in its delegate, before the resource drop, so the
+  wiring tripwire stays loud instead of dropping a resource-context family
+  silently.
+- The logs coerced-column schema value carries the body mode; the flag reads
+  one time per call. RawRead's dummy-value parameter is a legacy-body shim
+  and leaves with the legacy body.
+- The compile context is named `CompileScope`: "scope" alone collides with
+  the span search scope, the vocabulary member scope, and the resolution
+  scope.
+
+## Findings a reviewer should weigh
+
+1. The condition-side consolidation is real and cheap: six flows became one,
+   with per-signal surface of exactly three methods each, and every golden
+   stayed byte-identical without adjustment.
+2. The column side splits: coerced modes unify on three knobs; raw select
+   does not pay for unification at today's shapes.
+3. The full tree model (candidates as data, one `Resolve`, generic raw
+   rendering) requires shape reconciliation that byte-parity forbids —
+   confirming it should ride a forcing feature (the ValueMap reader) with a
+   re-pinning round, not a standalone refactor.

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

@@ -95,65 +95,24 @@ func (provider *provider) Validate(ctx context.Context) error {
 	return nil
 }
 
-func (provider *provider) Activate(ctx context.Context, organizationID valuer.UUID, key string) (*licensetypes.License, error) {
-	zeusLicense, err := provider.zeus.GetLicense(ctx, key)
+func (provider *provider) Activate(ctx context.Context, organizationID valuer.UUID, key string) error {
+	data, err := provider.zeus.GetLicense(ctx, key)
 	if err != nil {
-		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "unable to fetch license data with upstream server")
+		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 nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to create license entity")
+		return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to create license entity")
 	}
 
 	storableLicense := licensetypes.NewStorableLicenseFromLicense(license)
 	err = provider.store.Create(ctx, storableLicense)
-	if err != nil {
-		return nil, err
-	}
-
-	return license, 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)
+	return nil
 }
 
 func (provider *provider) GetActive(ctx context.Context, organizationID valuer.UUID) (*licensetypes.License, error) {
@@ -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, systemDashboardRegistry dashboardtypes.SystemDashboardRegistry) 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) dashboard.Module {
 	scopedProviderSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/ee/modules/dashboard/impldashboard")
-	pkgDashboardModule := pkgimpldashboard.NewModule(store, settings, analytics, orgGetter, queryParser, tagModule, systemDashboardRegistry)
+	pkgDashboardModule := pkgimpldashboard.NewModule(store, settings, analytics, orgGetter, queryParser, tagModule)
 
 	return &module{
 		pkgDashboardModule: pkgDashboardModule,
@@ -361,14 +361,6 @@ 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/public/locales/en-GB/channels.json

@@ -26,55 +26,6 @@
   "tooltip_ms_teams_url": "The URL of the Microsoft Teams [webhook](https://support.microsoft.com/en-us/office/create-incoming-webhooks-with-workflows-for-microsoft-teams-8ae491c7-0394-4861-ba59-055e33f75498) to send alerts to. Learn more about Microsoft Teams integration in the docs [here](https://signoz.io/docs/alerts-management/notification-channel/ms-teams/).",
   "tooltip_google_chat_url": "The URL of the Google Chat space [incoming webhook](https://developers.google.com/workspace/chat/quickstart/webhooks) to send alerts to. It must be an https URL on chat.googleapis.com.",
   "google_chat_webhook_url_invalid": "Webhook URL must be an https URL on chat.googleapis.com",
-  "field_jira_site": "Site URL",
-  "tooltip_jira_site": "Your Jira Cloud base URL, e.g. https://your-domain.atlassian.net. Only Jira Cloud is supported.",
-  "jira_site_invalid": "Site URL must be an https URL on an atlassian.net domain",
-  "jira_required_fields": "Site URL, email, API token, project and issue type are required",
-  "jira_service_account_tip": "Recommended: use a Jira service account so alerts aren't reported under a personal name and the channel keeps working when someone leaves.",
-  "jira_service_account_tip_link": "Learn how",
-  "field_jira_email": "Email",
-  "help_jira_email": "The Atlassian account email used for authentication.",
-  "field_jira_api_token": "API token",
-  "help_jira_api_token": "Create one at id.atlassian.com under Security → API tokens.",
-  "field_jira_project": "Project key",
-  "field_jira_issue_type": "Issue type",
-  "help_jira_issue_type": "An issue type that exists in the project, e.g. Task, Bug or Incident.",
-  "field_jira_summary": "Summary (issue title)",
-  "help_jira_summary": "Template for the Jira issue title.",
-  "field_jira_description": "Description",
-  "help_jira_description": "Template for the issue description. Rendered as rich text with a status panel and links back to SigNoz.",
-  "jira_advanced_section": "Advanced Options",
-  "field_jira_priority": "Priority",
-  "placeholder_jira_priority": "Leave empty to use the project default",
-  "help_jira_priority": "Must match a priority in the project's scheme, e.g. High.",
-  "field_jira_labels": "Labels",
-  "placeholder_jira_labels": "Type a label and press Enter",
-  "help_jira_labels": "signoz and a deduplication label are added automatically.",
-  "field_jira_resolve_transition": "Resolve transition",
-  "field_jira_reopen_transition": "Reopen transition",
-  "help_jira_resolve_transition": "When the alert resolves, SigNoz moves the Jira issue to a \"Done\" status via a workflow transition. This is auto-detected — leave it empty unless your project has more than one \"Done\" transition (e.g. Done vs. Won't Do) and you want to force a specific one by name.",
-  "help_jira_reopen_transition": "When a resolved alert fires again (within the reopen window), SigNoz moves the issue back out of \"Done\" to an active status via a workflow transition. This is auto-detected — leave it empty unless you want to force a specific one by name (e.g. To Do or Reopen).",
-  "placeholder_jira_resolve_transition": "Auto-detected, e.g. Done",
-  "placeholder_jira_reopen_transition": "Auto-detected, e.g. To Do",
-  "field_jira_reopen_duration": "Reopen window",
-  "placeholder_jira_reopen_duration": "e.g. 72h",
-  "help_jira_reopen_duration": "If a resolved alert fires again within this window, the same ticket is reopened; after the window, a re-fire opens a new ticket instead. Default: 3d.",
-  "tooltip_jira_reopen_duration": "Accepted units: m (minutes), h (hours), d (days), w (weeks), y (years) — e.g. 30m, 72h or 3d. Minimum 1m.",
-  "jira_reopen_duration_invalid": "Reopen window must be a duration like 30m, 72h or 3d (minimum 1m)",
-  "jsmops_tip": "Create an API integration on your JSM team's Operations page and paste its key below.",
-  "jsmops_tip_link": "Learn how",
-  "field_jsmops_api_key": "API key",
-  "help_jsmops_api_key": "The JSM Ops integration API key, from your team's Operations → Integrations → API. Make sure the integration is turned on.",
-  "field_jsmops_message": "Message (alert title)",
-  "help_jsmops_message": "Template for the alert title. Truncated to 130 characters.",
-  "field_jsmops_description": "Description",
-  "help_jsmops_description": "Template for the alert description. Rendered as rich text; kept under 15,000 characters.",
-  "jsmops_advanced_section": "Advanced Options",
-  "field_jsmops_priority": "Priority",
-  "help_jsmops_priority": "Template resolving to one of P1–P5. Leave as-is to map from alert severity.",
-  "field_jsmops_tags": "Tags",
-  "placeholder_jsmops_tags": "Type a tag and press Enter",
-  "help_jsmops_tags": "Tags added to every alert.",
 
   "field_slack_recipient": "Recipient",
   "field_slack_title": "Title",

frontend/public/locales/en/channels.json

@@ -26,55 +26,6 @@
   "tooltip_ms_teams_url": "The URL of the Microsoft Teams [webhook](https://support.microsoft.com/en-us/office/create-incoming-webhooks-with-workflows-for-microsoft-teams-8ae491c7-0394-4861-ba59-055e33f75498) to send alerts to. Learn more about Microsoft Teams integration in the docs [here](https://signoz.io/docs/alerts-management/notification-channel/ms-teams/).",
   "tooltip_google_chat_url": "The URL of the Google Chat space [incoming webhook](https://developers.google.com/workspace/chat/quickstart/webhooks) to send alerts to. It must be an https URL on chat.googleapis.com.",
   "google_chat_webhook_url_invalid": "Webhook URL must be an https URL on chat.googleapis.com",
-  "field_jira_site": "Site URL",
-  "tooltip_jira_site": "Your Jira Cloud base URL, e.g. https://your-domain.atlassian.net. Only Jira Cloud is supported.",
-  "jira_site_invalid": "Site URL must be an https URL on an atlassian.net domain",
-  "jira_required_fields": "Site URL, email, API token, project and issue type are required",
-  "jira_service_account_tip": "Recommended: use a Jira service account so alerts aren't reported under a personal name and the channel keeps working when someone leaves.",
-  "jira_service_account_tip_link": "Learn how",
-  "field_jira_email": "Email",
-  "help_jira_email": "The Atlassian account email used for authentication.",
-  "field_jira_api_token": "API token",
-  "help_jira_api_token": "Create one at id.atlassian.com under Security → API tokens.",
-  "field_jira_project": "Project key",
-  "field_jira_issue_type": "Issue type",
-  "help_jira_issue_type": "An issue type that exists in the project, e.g. Task, Bug or Incident.",
-  "field_jira_summary": "Summary (issue title)",
-  "help_jira_summary": "Template for the Jira issue title.",
-  "field_jira_description": "Description",
-  "help_jira_description": "Template for the issue description. Rendered as rich text with a status panel and links back to SigNoz.",
-  "jira_advanced_section": "Advanced Options",
-  "field_jira_priority": "Priority",
-  "placeholder_jira_priority": "Leave empty to use the project default",
-  "help_jira_priority": "Must match a priority in the project's scheme, e.g. High.",
-  "field_jira_labels": "Labels",
-  "placeholder_jira_labels": "Type a label and press Enter",
-  "help_jira_labels": "signoz and a deduplication label are added automatically.",
-  "field_jira_resolve_transition": "Resolve transition",
-  "field_jira_reopen_transition": "Reopen transition",
-  "help_jira_resolve_transition": "When the alert resolves, SigNoz moves the Jira issue to a \"Done\" status via a workflow transition. This is auto-detected — leave it empty unless your project has more than one \"Done\" transition (e.g. Done vs. Won't Do) and you want to force a specific one by name.",
-  "help_jira_reopen_transition": "When a resolved alert fires again (within the reopen window), SigNoz moves the issue back out of \"Done\" to an active status via a workflow transition. This is auto-detected — leave it empty unless you want to force a specific one by name (e.g. To Do or Reopen).",
-  "placeholder_jira_resolve_transition": "Auto-detected, e.g. Done",
-  "placeholder_jira_reopen_transition": "Auto-detected, e.g. To Do",
-  "field_jira_reopen_duration": "Reopen window",
-  "placeholder_jira_reopen_duration": "e.g. 72h",
-  "help_jira_reopen_duration": "If a resolved alert fires again within this window, the same ticket is reopened; after the window, a re-fire opens a new ticket instead. Default: 3d.",
-  "tooltip_jira_reopen_duration": "Accepted units: m (minutes), h (hours), d (days), w (weeks), y (years) — e.g. 30m, 72h or 3d. Minimum 1m.",
-  "jira_reopen_duration_invalid": "Reopen window must be a duration like 30m, 72h or 3d (minimum 1m)",
-  "jsmops_tip": "Create an API integration on your JSM team's Operations page and paste its key below.",
-  "jsmops_tip_link": "Learn how",
-  "field_jsmops_api_key": "API key",
-  "help_jsmops_api_key": "The JSM Ops integration API key, from your team's Operations → Integrations → API. Make sure the integration is turned on.",
-  "field_jsmops_message": "Message (alert title)",
-  "help_jsmops_message": "Template for the alert title. Truncated to 130 characters.",
-  "field_jsmops_description": "Description",
-  "help_jsmops_description": "Template for the alert description. Rendered as rich text; kept under 15,000 characters.",
-  "jsmops_advanced_section": "Advanced Options",
-  "field_jsmops_priority": "Priority",
-  "help_jsmops_priority": "Template resolving to one of P1–P5. Leave as-is to map from alert severity.",
-  "field_jsmops_tags": "Tags",
-  "placeholder_jsmops_tags": "Type a tag and press Enter",
-  "help_jsmops_tags": "Tags added to every alert.",
   "field_slack_recipient": "Recipient",
   "field_slack_title": "Title",
   "field_slack_description": "Description",

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

@@ -103,30 +103,30 @@ function createMockLicense(
 	overrides: Partial<LicenseResModel> = {},
 ): LicenseResModel {
 	return {
-		id: 'test-license-id',
-		eventQueue: {
-			createdAt: '0',
+		key: 'test-key',
+		event_queue: {
+			created_at: '0',
 			event: LicenseEvent.NO_EVENT,
-			scheduledAt: '0',
+			scheduled_at: '0',
 			status: '',
-			updatedAt: '0',
+			updated_at: '0',
 		},
 		state: LicenseState.ACTIVATED,
 		status: LicenseStatus.VALID,
 		platform: LicensePlatform.CLOUD,
-		createdAt: '0',
+		created_at: '0',
 		plan: {
-			id: '0',
-			createdAt: '0',
+			created_at: '0',
 			description: '',
-			isActive: true,
+			is_active: true,
 			name: '',
-			updatedAt: '0',
+			updated_at: '0',
 		},
-		freeUntil: '0',
-		updatedAt: '0',
-		validFrom: 0,
-		validUntil: 0,
+		plan_id: '0',
+		free_until: '0',
+		updated_at: '0',
+		valid_from: 0,
+		valid_until: 0,
 		...overrides,
 	};
 }
@@ -850,22 +850,6 @@ describe('PrivateRoute', () => {
 			assertStaysOnRoute(ROUTES.WORKSPACE_LOCKED);
 		});
 
-		it('should keep a custom role (ANONYMOUS) on workspace locked instead of bouncing to unauthorized', () => {
-			renderPrivateRoute({
-				initialRoute: ROUTES.WORKSPACE_LOCKED,
-				appContext: {
-					isLoggedIn: true,
-					isFetchingActiveLicense: false,
-					activeLicense: createMockLicense({ platform: LicensePlatform.CLOUD }),
-					trialInfo: createMockTrialInfo({ workSpaceBlock: true }),
-					user: createMockUser({ role: USER_ROLES.ANONYMOUS as ROLES }),
-				},
-				isCloudUser: true,
-			});
-
-			assertStaysOnRoute(ROUTES.WORKSPACE_LOCKED);
-		});
-
 		it('should not redirect self-hosted users to workspace locked even when workSpaceBlock is true', () => {
 			renderPrivateRoute({
 				initialRoute: ROUTES.HOME,
@@ -1040,24 +1024,6 @@ describe('PrivateRoute', () => {
 			assertStaysOnRoute(ROUTES.WORKSPACE_SUSPENDED);
 		});
 
-		it('should keep a custom role (ANONYMOUS) on workspace suspended instead of bouncing to unauthorized', () => {
-			renderPrivateRoute({
-				initialRoute: ROUTES.WORKSPACE_SUSPENDED,
-				appContext: {
-					isLoggedIn: true,
-					isFetchingActiveLicense: false,
-					activeLicense: createMockLicense({
-						platform: LicensePlatform.CLOUD,
-						state: LicenseState.DEFAULTED,
-					}),
-					user: createMockUser({ role: USER_ROLES.ANONYMOUS as ROLES }),
-				},
-				isCloudUser: true,
-			});
-
-			assertStaysOnRoute(ROUTES.WORKSPACE_SUSPENDED);
-		});
-
 		it('should not redirect self-hosted users to workspace suspended when license is defaulted', () => {
 			renderPrivateRoute({
 				initialRoute: ROUTES.HOME,
@@ -1614,18 +1580,6 @@ describe('PrivateRoute', () => {
 				path: ROUTES.SUPPORT,
 				deniedRoles: [USER_ROLES.AUTHOR as ROLES],
 			},
-			WORKSPACE_LOCKED: {
-				path: ROUTES.WORKSPACE_LOCKED,
-				deniedRoles: DENIED_ROLES,
-			},
-			WORKSPACE_SUSPENDED: {
-				path: ROUTES.WORKSPACE_SUSPENDED,
-				deniedRoles: DENIED_ROLES,
-			},
-			WORKSPACE_ACCESS_RESTRICTED: {
-				path: ROUTES.WORKSPACE_ACCESS_RESTRICTED,
-				deniedRoles: DENIED_ROLES,
-			},
 		};
 
 		const authzRouteRolePairs: [string, string, ROLES][] = Object.entries(

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

@@ -46,8 +46,6 @@ import type {
 	GetPublicDashboardPathParameters,
 	GetPublicDashboardWidgetQueryRange200,
 	GetPublicDashboardWidgetQueryRangePathParameters,
-	GetSystemDashboard200,
-	GetSystemDashboardPathParameters,
 	ListDashboardViews200,
 	ListDashboardsForUserV2200,
 	ListDashboardsForUserV2Params,
@@ -1887,108 +1885,6 @@ 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,702 +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 {
-	ActivateLicense201,
-	DeleteLicensePathParameters,
-	GetActiveLicense200,
-	GetLicense200,
-	GetLicensePathParameters,
-	LicensetypesPostableLicenseDTO,
-	ListLicenses200,
-	RefreshLicensePathParameters,
-	RenderErrorResponseDTO,
-} from '../sigNoz.schemas';
-
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
-
-/**
- * This endpoint validates the license key with the upstream server and activates the license for the organization.
- * @deprecated
- * @summary Activate a license.
- */
-export const activateLicenseDeprecated = (
-	licensetypesPostableLicenseDTO?: BodyType<LicensetypesPostableLicenseDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v3/licenses`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: licensetypesPostableLicenseDTO,
-		signal,
-	});
-};
-
-export const getActivateLicenseDeprecatedMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof activateLicenseDeprecated>>,
-		TError,
-		{ data?: BodyType<LicensetypesPostableLicenseDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof activateLicenseDeprecated>>,
-	TError,
-	{ data?: BodyType<LicensetypesPostableLicenseDTO> },
-	TContext
-> => {
-	const mutationKey = ['activateLicenseDeprecated'];
-	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 activateLicenseDeprecated>>,
-		{ data?: BodyType<LicensetypesPostableLicenseDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return activateLicenseDeprecated(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type ActivateLicenseDeprecatedMutationResult = NonNullable<
-	Awaited<ReturnType<typeof activateLicenseDeprecated>>
->;
-export type ActivateLicenseDeprecatedMutationBody =
-	| BodyType<LicensetypesPostableLicenseDTO>
-	| undefined;
-export type ActivateLicenseDeprecatedMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @deprecated
- * @summary Activate a license.
- */
-export const useActivateLicenseDeprecated = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof activateLicenseDeprecated>>,
-		TError,
-		{ data?: BodyType<LicensetypesPostableLicenseDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof activateLicenseDeprecated>>,
-	TError,
-	{ data?: BodyType<LicensetypesPostableLicenseDTO> },
-	TContext
-> => {
-	return useMutation(getActivateLicenseDeprecatedMutationOptions(options));
-};
-/**
- * This endpoint refreshes the active license of the organization from the upstream server.
- * @deprecated
- * @summary Refresh a license.
- */
-export const refreshLicenseDeprecated = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v3/licenses`,
-		method: 'PUT',
-		signal,
-	});
-};
-
-export const getRefreshLicenseDeprecatedMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof refreshLicenseDeprecated>>,
-		TError,
-		void,
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof refreshLicenseDeprecated>>,
-	TError,
-	void,
-	TContext
-> => {
-	const mutationKey = ['refreshLicenseDeprecated'];
-	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 refreshLicenseDeprecated>>,
-		void
-	> = () => {
-		return refreshLicenseDeprecated();
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type RefreshLicenseDeprecatedMutationResult = NonNullable<
-	Awaited<ReturnType<typeof refreshLicenseDeprecated>>
->;
-
-export type RefreshLicenseDeprecatedMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @deprecated
- * @summary Refresh a license.
- */
-export const useRefreshLicenseDeprecated = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof refreshLicenseDeprecated>>,
-		TError,
-		void,
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof refreshLicenseDeprecated>>,
-	TError,
-	void,
-	TContext
-> => {
-	return useMutation(getRefreshLicenseDeprecatedMutationOptions(options));
-};
-/**
- * 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<ActivateLicense201>({
-		url: `/api/v4/licenses`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: licensetypesPostableLicenseDTO,
-		signal,
-	});
-};
-
-export const getActivateLicenseMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof activateLicense>>,
-		TError,
-		{ data?: BodyType<LicensetypesPostableLicenseDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof activateLicense>>,
-	TError,
-	{ data?: BodyType<LicensetypesPostableLicenseDTO> },
-	TContext
-> => {
-	const mutationKey = ['activateLicense'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof activateLicense>>,
-		{ data?: BodyType<LicensetypesPostableLicenseDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return activateLicense(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type ActivateLicenseMutationResult = NonNullable<
-	Awaited<ReturnType<typeof activateLicense>>
->;
-export type ActivateLicenseMutationBody =
-	| BodyType<LicensetypesPostableLicenseDTO>
-	| undefined;
-export type ActivateLicenseMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Activate a license.
- */
-export const useActivateLicense = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof activateLicense>>,
-		TError,
-		{ data?: BodyType<LicensetypesPostableLicenseDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof activateLicense>>,
-	TError,
-	{ data?: BodyType<LicensetypesPostableLicenseDTO> },
-	TContext
-> => {
-	return useMutation(getActivateLicenseMutationOptions(options));
-};
-/**
- * This endpoint deletes the license by id. Licenses managed by SigNoz Cloud cannot be deleted.
- * @summary Delete a license.
- */
-export const deleteLicense = (
-	{ id }: DeleteLicensePathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v4/licenses/${id}`,
-		method: 'DELETE',
-		signal,
-	});
-};
-
-export const getDeleteLicenseMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteLicense>>,
-		TError,
-		{ pathParams: DeleteLicensePathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteLicense>>,
-	TError,
-	{ pathParams: DeleteLicensePathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteLicense'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof deleteLicense>>,
-		{ pathParams: DeleteLicensePathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteLicense(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteLicenseMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteLicense>>
->;
-
-export type DeleteLicenseMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete a license.
- */
-export const useDeleteLicense = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteLicense>>,
-		TError,
-		{ pathParams: DeleteLicensePathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteLicense>>,
-	TError,
-	{ pathParams: DeleteLicensePathParameters },
-	TContext
-> => {
-	return useMutation(getDeleteLicenseMutationOptions(options));
-};
-/**
- * This endpoint gets the license by id.
- * @summary Get a license.
- */
-export const getLicense = (
-	{ id }: GetLicensePathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetLicense200>({
-		url: `/api/v4/licenses/${id}`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetLicenseQueryKey = ({ id }: GetLicensePathParameters) => {
-	return [`/api/v4/licenses/${id}`] as const;
-};
-
-export const getGetLicenseQueryOptions = <
-	TData = Awaited<ReturnType<typeof getLicense>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ id }: GetLicensePathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getLicense>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getGetLicenseQueryKey({ id });
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof getLicense>>> = ({
-		signal,
-	}) => getLicense({ id }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<Awaited<ReturnType<typeof getLicense>>, TError, TData> & {
-		queryKey: QueryKey;
-	};
-};
-
-export type GetLicenseQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getLicense>>
->;
-export type GetLicenseQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get a license.
- */
-
-export function useGetLicense<
-	TData = Awaited<ReturnType<typeof getLicense>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ id }: GetLicensePathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getLicense>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetLicenseQueryOptions({ id }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Get a license.
- */
-export const invalidateGetLicense = async (
-	queryClient: QueryClient,
-	{ id }: GetLicensePathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetLicenseQueryKey({ id }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint refreshes the active license of the organization from the upstream server.
- * @summary Refresh a license.
- */
-export const refreshLicense = (
-	{ id }: RefreshLicensePathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v4/licenses/${id}`,
-		method: 'PUT',
-		signal,
-	});
-};
-
-export const getRefreshLicenseMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof refreshLicense>>,
-		TError,
-		{ pathParams: RefreshLicensePathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof refreshLicense>>,
-	TError,
-	{ pathParams: RefreshLicensePathParameters },
-	TContext
-> => {
-	const mutationKey = ['refreshLicense'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof refreshLicense>>,
-		{ pathParams: RefreshLicensePathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return refreshLicense(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type RefreshLicenseMutationResult = NonNullable<
-	Awaited<ReturnType<typeof refreshLicense>>
->;
-
-export type RefreshLicenseMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Refresh a license.
- */
-export const useRefreshLicense = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof refreshLicense>>,
-		TError,
-		{ pathParams: RefreshLicensePathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof refreshLicense>>,
-	TError,
-	{ pathParams: RefreshLicensePathParameters },
-	TContext
-> => {
-	return useMutation(getRefreshLicenseMutationOptions(options));
-};
-/**
- * This endpoint gets the active license of the organization.
- * @summary Get the active license.
- */
-export const getActiveLicense = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<GetActiveLicense200>({
-		url: `/api/v4/licenses/active`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetActiveLicenseQueryKey = () => {
-	return [`/api/v4/licenses/active`] as const;
-};
-
-export const getGetActiveLicenseQueryOptions = <
-	TData = Awaited<ReturnType<typeof getActiveLicense>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof getActiveLicense>>,
-		TError,
-		TData
-	>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getGetActiveLicenseQueryKey();
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof getActiveLicense>>> = ({
-		signal,
-	}) => getActiveLicense(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof getActiveLicense>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetActiveLicenseQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getActiveLicense>>
->;
-export type GetActiveLicenseQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get the active license.
- */
-
-export function useGetActiveLicense<
-	TData = Awaited<ReturnType<typeof getActiveLicense>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof getActiveLicense>>,
-		TError,
-		TData
-	>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetActiveLicenseQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Get the active license.
- */
-export const invalidateGetActiveLicense = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetActiveLicenseQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};

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

@@ -1,396 +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 {
-	PrometheusErrorResponseSchemaDTO,
-	PrometheusQueryParams,
-	PrometheusQueryPostParams,
-	PrometheusQueryRangeParams,
-	PrometheusQueryRangePostParams,
-	PrometheusSuccessResponseSchemaDTO,
-	RenderErrorResponseDTO,
-} from '../sigNoz.schemas';
-
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type { ErrorType } from '../../../generatedAPIInstance';
-
-/**
- * Prometheus-compatible endpoint: the request and response contract is the upstream Prometheus HTTP API (https://prometheus.io/docs/prometheus/latest/querying/api/). Parameters are accepted as URL query parameters or a form-encoded body, on GET and POST alike.
- * @summary Prometheus instant query
- */
-export const prometheusQuery = (
-	params: PrometheusQueryParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<PrometheusSuccessResponseSchemaDTO>({
-		url: `/prometheus/api/v1/query`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getPrometheusQueryQueryKey = (params?: PrometheusQueryParams) => {
-	return [`/prometheus/api/v1/query`, ...(params ? [params] : [])] as const;
-};
-
-export const getPrometheusQueryQueryOptions = <
-	TData = Awaited<ReturnType<typeof prometheusQuery>>,
-	TError = ErrorType<PrometheusErrorResponseSchemaDTO | RenderErrorResponseDTO>,
->(
-	params: PrometheusQueryParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof prometheusQuery>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getPrometheusQueryQueryKey(params);
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof prometheusQuery>>> = ({
-		signal,
-	}) => prometheusQuery(params, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof prometheusQuery>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type PrometheusQueryQueryResult = NonNullable<
-	Awaited<ReturnType<typeof prometheusQuery>>
->;
-export type PrometheusQueryQueryError = ErrorType<
-	PrometheusErrorResponseSchemaDTO | RenderErrorResponseDTO
->;
-
-/**
- * @summary Prometheus instant query
- */
-
-export function usePrometheusQuery<
-	TData = Awaited<ReturnType<typeof prometheusQuery>>,
-	TError = ErrorType<PrometheusErrorResponseSchemaDTO | RenderErrorResponseDTO>,
->(
-	params: PrometheusQueryParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof prometheusQuery>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getPrometheusQueryQueryOptions(params, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Prometheus instant query
- */
-export const invalidatePrometheusQuery = async (
-	queryClient: QueryClient,
-	params: PrometheusQueryParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getPrometheusQueryQueryKey(params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Prometheus-compatible endpoint: the request and response contract is the upstream Prometheus HTTP API (https://prometheus.io/docs/prometheus/latest/querying/api/). Parameters are accepted as URL query parameters or a form-encoded body, on GET and POST alike.
- * @summary Prometheus instant query
- */
-export const prometheusQueryPost = (
-	params: PrometheusQueryPostParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<PrometheusSuccessResponseSchemaDTO>({
-		url: `/prometheus/api/v1/query`,
-		method: 'POST',
-		params,
-		signal,
-	});
-};
-
-export const getPrometheusQueryPostMutationOptions = <
-	TError = ErrorType<PrometheusErrorResponseSchemaDTO | RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof prometheusQueryPost>>,
-		TError,
-		{ params: PrometheusQueryPostParams },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof prometheusQueryPost>>,
-	TError,
-	{ params: PrometheusQueryPostParams },
-	TContext
-> => {
-	const mutationKey = ['prometheusQueryPost'];
-	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 prometheusQueryPost>>,
-		{ params: PrometheusQueryPostParams }
-	> = (props) => {
-		const { params } = props ?? {};
-
-		return prometheusQueryPost(params);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type PrometheusQueryPostMutationResult = NonNullable<
-	Awaited<ReturnType<typeof prometheusQueryPost>>
->;
-
-export type PrometheusQueryPostMutationError = ErrorType<
-	PrometheusErrorResponseSchemaDTO | RenderErrorResponseDTO
->;
-
-/**
- * @summary Prometheus instant query
- */
-export const usePrometheusQueryPost = <
-	TError = ErrorType<PrometheusErrorResponseSchemaDTO | RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof prometheusQueryPost>>,
-		TError,
-		{ params: PrometheusQueryPostParams },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof prometheusQueryPost>>,
-	TError,
-	{ params: PrometheusQueryPostParams },
-	TContext
-> => {
-	return useMutation(getPrometheusQueryPostMutationOptions(options));
-};
-/**
- * Prometheus-compatible endpoint: the request and response contract is the upstream Prometheus HTTP API (https://prometheus.io/docs/prometheus/latest/querying/api/). Parameters are accepted as URL query parameters or a form-encoded body, on GET and POST alike.
- * @summary Prometheus range query
- */
-export const prometheusQueryRange = (
-	params: PrometheusQueryRangeParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<PrometheusSuccessResponseSchemaDTO>({
-		url: `/prometheus/api/v1/query_range`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getPrometheusQueryRangeQueryKey = (
-	params?: PrometheusQueryRangeParams,
-) => {
-	return [
-		`/prometheus/api/v1/query_range`,
-		...(params ? [params] : []),
-	] as const;
-};
-
-export const getPrometheusQueryRangeQueryOptions = <
-	TData = Awaited<ReturnType<typeof prometheusQueryRange>>,
-	TError = ErrorType<PrometheusErrorResponseSchemaDTO | RenderErrorResponseDTO>,
->(
-	params: PrometheusQueryRangeParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof prometheusQueryRange>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getPrometheusQueryRangeQueryKey(params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof prometheusQueryRange>>
-	> = ({ signal }) => prometheusQueryRange(params, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof prometheusQueryRange>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type PrometheusQueryRangeQueryResult = NonNullable<
-	Awaited<ReturnType<typeof prometheusQueryRange>>
->;
-export type PrometheusQueryRangeQueryError = ErrorType<
-	PrometheusErrorResponseSchemaDTO | RenderErrorResponseDTO
->;
-
-/**
- * @summary Prometheus range query
- */
-
-export function usePrometheusQueryRange<
-	TData = Awaited<ReturnType<typeof prometheusQueryRange>>,
-	TError = ErrorType<PrometheusErrorResponseSchemaDTO | RenderErrorResponseDTO>,
->(
-	params: PrometheusQueryRangeParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof prometheusQueryRange>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getPrometheusQueryRangeQueryOptions(params, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Prometheus range query
- */
-export const invalidatePrometheusQueryRange = async (
-	queryClient: QueryClient,
-	params: PrometheusQueryRangeParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getPrometheusQueryRangeQueryKey(params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Prometheus-compatible endpoint: the request and response contract is the upstream Prometheus HTTP API (https://prometheus.io/docs/prometheus/latest/querying/api/). Parameters are accepted as URL query parameters or a form-encoded body, on GET and POST alike.
- * @summary Prometheus range query
- */
-export const prometheusQueryRangePost = (
-	params: PrometheusQueryRangePostParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<PrometheusSuccessResponseSchemaDTO>({
-		url: `/prometheus/api/v1/query_range`,
-		method: 'POST',
-		params,
-		signal,
-	});
-};
-
-export const getPrometheusQueryRangePostMutationOptions = <
-	TError = ErrorType<PrometheusErrorResponseSchemaDTO | RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof prometheusQueryRangePost>>,
-		TError,
-		{ params: PrometheusQueryRangePostParams },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof prometheusQueryRangePost>>,
-	TError,
-	{ params: PrometheusQueryRangePostParams },
-	TContext
-> => {
-	const mutationKey = ['prometheusQueryRangePost'];
-	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 prometheusQueryRangePost>>,
-		{ params: PrometheusQueryRangePostParams }
-	> = (props) => {
-		const { params } = props ?? {};
-
-		return prometheusQueryRangePost(params);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type PrometheusQueryRangePostMutationResult = NonNullable<
-	Awaited<ReturnType<typeof prometheusQueryRangePost>>
->;
-
-export type PrometheusQueryRangePostMutationError = ErrorType<
-	PrometheusErrorResponseSchemaDTO | RenderErrorResponseDTO
->;
-
-/**
- * @summary Prometheus range query
- */
-export const usePrometheusQueryRangePost = <
-	TError = ErrorType<PrometheusErrorResponseSchemaDTO | RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof prometheusQueryRangePost>>,
-		TError,
-		{ params: PrometheusQueryRangePostParams },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof prometheusQueryRangePost>>,
-	TError,
-	{ params: PrometheusQueryRangePostParams },
-	TContext
-> => {
-	return useMutation(getPrometheusQueryRangePostMutationOptions(options));
-};

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

@@ -385,93 +385,6 @@ export interface AlertmanagertypesGoogleChatReceiverConfigDTO {
 	webhook_url?: ConfigSecretURLDTO;
 }
 
-export interface AlertmanagertypesJSMOpsReceiverConfigDTO {
-	/**
-	 * @type string
-	 */
-	api_key?: string;
-	/**
-	 * @type string
-	 */
-	description?: string;
-	http_config?: ConfigHTTPClientConfigDTO;
-	/**
-	 * @type string
-	 */
-	message?: string;
-	/**
-	 * @type string
-	 */
-	priority?: string;
-	/**
-	 * @type boolean
-	 */
-	send_resolved?: boolean;
-	/**
-	 * @type string
-	 */
-	tags?: string;
-}
-
-export type AlertmanagertypesJiraReceiverConfigDTOCustomFields = {
-	[key: string]: unknown;
-};
-
-export type ModelDurationDTO = number;
-
-export interface AlertmanagertypesJiraReceiverConfigDTO {
-	/**
-	 * @type object
-	 */
-	custom_fields?: AlertmanagertypesJiraReceiverConfigDTOCustomFields;
-	/**
-	 * @type string
-	 */
-	description?: string;
-	http_config?: ConfigHTTPClientConfigDTO;
-	/**
-	 * @type string
-	 */
-	issue_type?: string;
-	/**
-	 * @type array
-	 */
-	labels?: string[];
-	/**
-	 * @type string
-	 */
-	priority?: string;
-	/**
-	 * @type string
-	 */
-	project?: string;
-	reopen_duration?: ModelDurationDTO;
-	/**
-	 * @type string
-	 */
-	reopen_transition?: string;
-	/**
-	 * @type string
-	 */
-	resolve_transition?: string;
-	/**
-	 * @type boolean
-	 */
-	send_resolved?: boolean;
-	/**
-	 * @type string
-	 */
-	site?: string;
-	/**
-	 * @type string
-	 */
-	summary?: string;
-	/**
-	 * @type string
-	 */
-	wont_fix_resolution?: string;
-}
-
 export enum AlertmanagertypesMaintenanceKindDTO {
 	fixed = 'fixed',
 	recurring = 'recurring',
@@ -718,6 +631,69 @@ export interface ConfigIncidentioConfigDTO {
 	url_file?: string;
 }
 
+export interface ConfigJiraFieldConfigDTO {
+	/**
+	 * @type boolean,null
+	 */
+	enable_update?: boolean | null;
+	/**
+	 * @type string
+	 */
+	template?: string;
+}
+
+export type ModelDurationDTO = number;
+
+export type ConfigJiraConfigDTOCustomFields = { [key: string]: unknown };
+
+export interface ConfigJiraConfigDTO {
+	/**
+	 * @type string
+	 */
+	api_type?: string;
+	api_url?: ConfigURLType2DTO;
+	/**
+	 * @type object
+	 */
+	custom_fields?: ConfigJiraConfigDTOCustomFields;
+	description?: ConfigJiraFieldConfigDTO;
+	http_config?: ConfigHTTPClientConfigDTO;
+	/**
+	 * @type string
+	 */
+	issue_type?: string;
+	/**
+	 * @type array
+	 */
+	labels?: string[];
+	/**
+	 * @type string
+	 */
+	priority?: string;
+	/**
+	 * @type string
+	 */
+	project?: string;
+	reopen_duration?: ModelDurationDTO;
+	/**
+	 * @type string
+	 */
+	reopen_transition?: string;
+	/**
+	 * @type string
+	 */
+	resolve_transition?: string;
+	/**
+	 * @type boolean
+	 */
+	send_resolved?: boolean;
+	summary?: ConfigJiraFieldConfigDTO;
+	/**
+	 * @type string
+	 */
+	wont_fix_resolution?: string;
+}
+
 export interface ConfigMattermostFieldDTO {
 	/**
 	 * @type boolean,null
@@ -1676,11 +1652,7 @@ export type AlertmanagertypesPostableChannelDTO = unknown & {
 	/**
 	 * @type array
 	 */
-	jira_configs?: AlertmanagertypesJiraReceiverConfigDTO[];
-	/**
-	 * @type array
-	 */
-	jsmops_configs?: AlertmanagertypesJSMOpsReceiverConfigDTO[];
+	jira_configs?: ConfigJiraConfigDTO[];
 	/**
 	 * @type array
 	 */
@@ -1807,11 +1779,7 @@ export interface AlertmanagertypesReceiverDTO {
 	/**
 	 * @type array
 	 */
-	jira_configs?: AlertmanagertypesJiraReceiverConfigDTO[];
-	/**
-	 * @type array
-	 */
-	jsmops_configs?: AlertmanagertypesJSMOpsReceiverConfigDTO[];
+	jira_configs?: ConfigJiraConfigDTO[];
 	/**
 	 * @type array
 	 */
@@ -3300,67 +3268,6 @@ export interface CommonJSONRefDTO {
 	$ref?: string;
 }
 
-export type ConfigJiraConfigDTOCustomFields = { [key: string]: unknown };
-
-export interface ConfigJiraFieldConfigDTO {
-	/**
-	 * @type boolean,null
-	 */
-	enable_update?: boolean | null;
-	/**
-	 * @type string
-	 */
-	template?: string;
-}
-
-export interface ConfigJiraConfigDTO {
-	/**
-	 * @type string
-	 */
-	api_type?: string;
-	api_url?: ConfigURLType2DTO;
-	/**
-	 * @type object
-	 */
-	custom_fields?: ConfigJiraConfigDTOCustomFields;
-	description?: ConfigJiraFieldConfigDTO;
-	http_config?: ConfigHTTPClientConfigDTO;
-	/**
-	 * @type string
-	 */
-	issue_type?: string;
-	/**
-	 * @type array
-	 */
-	labels?: string[];
-	/**
-	 * @type string
-	 */
-	priority?: string;
-	/**
-	 * @type string
-	 */
-	project?: string;
-	reopen_duration?: ModelDurationDTO;
-	/**
-	 * @type string
-	 */
-	reopen_transition?: string;
-	/**
-	 * @type string
-	 */
-	resolve_transition?: string;
-	/**
-	 * @type boolean
-	 */
-	send_resolved?: boolean;
-	summary?: ConfigJiraFieldConfigDTO;
-	/**
-	 * @type string
-	 */
-	wont_fix_resolution?: string;
-}
-
 export interface DashboardGridItemDTO {
 	content?: CommonJSONRefDTO;
 	/**
@@ -5053,53 +4960,6 @@ 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',
@@ -7313,249 +7173,6 @@ export interface InframonitoringtypesVolumesDTO {
 	warning?: Querybuildertypesv5QueryWarnDataDTO;
 }
 
-export interface LicensetypesFeatureDTO {
-	/**
-	 * @type boolean
-	 */
-	active?: boolean;
-	/**
-	 * @type string
-	 */
-	name?: string;
-	/**
-	 * @type string
-	 */
-	route?: string;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	usage?: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	usage_limit?: number;
-}
-
-export interface LicensetypesLicenseEventQueueDTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt: string;
-	/**
-	 * @type string
-	 */
-	event: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	scheduledAt: string;
-	/**
-	 * @type string
-	 */
-	status: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt: string;
-}
-
-export interface LicensetypesLicensePlanDTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt: string;
-	/**
-	 * @type string
-	 */
-	description: string;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type boolean
-	 */
-	isActive: boolean;
-	/**
-	 * @type string
-	 */
-	name: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt: string;
-}
-
-export interface LicensetypesGettableActiveLicenseDTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt: string;
-	eventQueue: LicensetypesLicenseEventQueueDTO;
-	/**
-	 * @type array
-	 */
-	features: LicensetypesFeatureDTO[];
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	freeUntil: string;
-	/**
-	 * @type string
-	 */
-	id: string;
-	plan: LicensetypesLicensePlanDTO;
-	/**
-	 * @type string
-	 */
-	platform: string;
-	/**
-	 * @type string
-	 */
-	state: string;
-	/**
-	 * @type string
-	 */
-	status: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt: string;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	validFrom: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	validUntil: number;
-}
-
-export interface LicensetypesGettableLicenseDTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt: string;
-	eventQueue: LicensetypesLicenseEventQueueDTO;
-	/**
-	 * @type array
-	 */
-	features: LicensetypesFeatureDTO[];
-	/**
-	 * @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
-	 */
-	features: LicensetypesFeatureDTO[];
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	freeUntil: string;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type string
-	 * @format password
-	 */
-	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
-	 * @format password
-	 */
-	key?: string;
-}
-
 /**
  * @nullable
  */
@@ -8357,164 +7974,6 @@ export interface PreferencetypesUpdatablePreferenceDTO {
 	value?: unknown;
 }
 
-export enum PrometheusErrorResponseSchemaDTOErrorType {
-	bad_data = 'bad_data',
-	execution = 'execution',
-	canceled = 'canceled',
-	timeout = 'timeout',
-	internal = 'internal',
-}
-export enum PrometheusErrorResponseSchemaDTOStatus {
-	error = 'error',
-}
-export interface PrometheusErrorResponseSchemaDTO {
-	/**
-	 * @type string
-	 */
-	error: string;
-	/**
-	 * @enum bad_data,execution,canceled,timeout,internal
-	 * @type string
-	 */
-	errorType: PrometheusErrorResponseSchemaDTOErrorType;
-	/**
-	 * @enum error
-	 * @type string
-	 */
-	status: PrometheusErrorResponseSchemaDTOStatus;
-}
-
-export enum PrometheusMatrixDataSchemaDTOResultType {
-	matrix = 'matrix',
-}
-export type PrometheusSamplePairSchemaDTOItem = number | string;
-
-/**
- * A [timestamp, value] pair: float unix seconds, then the string-encoded sample value ("NaN", "+Inf", "-Inf" included).
- * @minItems 2
- * @maxItems 2
- * @nullable
- */
-export type PrometheusSamplePairSchemaDTO =
-	| PrometheusSamplePairSchemaDTOItem[]
-	| null;
-
-export type PrometheusMatrixSeriesSchemaDTOMetricAnyOf = {
-	[key: string]: string;
-};
-
-/**
- * @nullable
- */
-export type PrometheusMatrixSeriesSchemaDTOMetric =
-	PrometheusMatrixSeriesSchemaDTOMetricAnyOf | null;
-
-export interface PrometheusMatrixSeriesSchemaDTO {
-	/**
-	 * @type object,null
-	 */
-	metric: PrometheusMatrixSeriesSchemaDTOMetric;
-	/**
-	 * @type array,null
-	 */
-	values: (PrometheusSamplePairSchemaDTO | null)[] | null;
-}
-
-export interface PrometheusMatrixDataSchemaDTO {
-	/**
-	 * @type array,null
-	 */
-	result: PrometheusMatrixSeriesSchemaDTO[] | null;
-	/**
-	 * @enum matrix
-	 * @type string
-	 */
-	resultType: PrometheusMatrixDataSchemaDTOResultType;
-}
-
-export type PrometheusVectorSampleSchemaDTOMetricAnyOf = {
-	[key: string]: string;
-};
-
-/**
- * @nullable
- */
-export type PrometheusVectorSampleSchemaDTOMetric =
-	PrometheusVectorSampleSchemaDTOMetricAnyOf | null;
-
-export interface PrometheusVectorSampleSchemaDTO {
-	/**
-	 * @type object,null
-	 */
-	metric: PrometheusVectorSampleSchemaDTOMetric;
-	value: PrometheusSamplePairSchemaDTO | null;
-}
-
-export enum PrometheusVectorDataSchemaDTOResultType {
-	vector = 'vector',
-}
-export interface PrometheusVectorDataSchemaDTO {
-	/**
-	 * @type array,null
-	 */
-	result: PrometheusVectorSampleSchemaDTO[] | null;
-	/**
-	 * @enum vector
-	 * @type string
-	 */
-	resultType: PrometheusVectorDataSchemaDTOResultType;
-}
-
-export enum PrometheusScalarDataSchemaDTOResultType {
-	scalar = 'scalar',
-}
-export interface PrometheusScalarDataSchemaDTO {
-	result: PrometheusSamplePairSchemaDTO | null;
-	/**
-	 * @enum scalar
-	 * @type string
-	 */
-	resultType: PrometheusScalarDataSchemaDTOResultType;
-}
-
-export enum PrometheusStringDataSchemaDTOResultType {
-	string = 'string',
-}
-export interface PrometheusStringDataSchemaDTO {
-	result: PrometheusSamplePairSchemaDTO | null;
-	/**
-	 * @enum string
-	 * @type string
-	 */
-	resultType: PrometheusStringDataSchemaDTOResultType;
-}
-
-export type PrometheusQueryDataSchemaDTO =
-	| PrometheusMatrixDataSchemaDTO
-	| PrometheusVectorDataSchemaDTO
-	| PrometheusScalarDataSchemaDTO
-	| PrometheusStringDataSchemaDTO;
-
-export enum PrometheusSuccessResponseSchemaDTOStatus {
-	success = 'success',
-}
-export interface PrometheusSuccessResponseSchemaDTO {
-	data: PrometheusQueryDataSchemaDTO;
-	/**
-	 * @type array
-	 */
-	infos?: string[];
-	/**
-	 * @enum success
-	 * @type string
-	 */
-	status: PrometheusSuccessResponseSchemaDTOStatus;
-	/**
-	 * @type array
-	 */
-	warnings?: string[];
-}
-
 export interface PromotetypesWrappedIndexDTO {
 	fieldDataType?: TelemetrytypesFieldDataTypeDTO;
 	/**
@@ -11854,17 +11313,6 @@ export type MigrateDashboardV2200 = {
 	status: string;
 };
 
-export type GetSystemDashboardPathParameters = {
-	name: string;
-};
-export type GetSystemDashboard200 = {
-	data: DashboardtypesGettableSystemDashboardDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetFeatures200 = {
 	/**
 	 * @type array
@@ -12981,50 +12429,6 @@ export type GetFlamegraph200 = {
 	status: string;
 };
 
-export type ListLicenses200 = {
-	/**
-	 * @type array
-	 */
-	data: LicensetypesGettableLicenseDTO[];
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type ActivateLicense201 = {
-	data: TypesIdentifiableDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type DeleteLicensePathParameters = {
-	id: string;
-};
-export type GetLicensePathParameters = {
-	id: string;
-};
-export type GetLicense200 = {
-	data: LicensetypesGettableLicenseWithKeyDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type RefreshLicensePathParameters = {
-	id: string;
-};
-export type GetActiveLicense200 = {
-	data: LicensetypesGettableActiveLicenseDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetWaterfallV4PathParameters = {
 	traceID: string;
 };
@@ -13067,115 +12471,3 @@ export type ReplaceVariables200 = {
 	 */
 	status: string;
 };
-
-export type PrometheusQueryParams = {
-	/**
-	 * @type string
-	 * @description PromQL expression.
-	 */
-	query: string;
-	/**
-	 * @type string
-	 * @description Evaluation timestamp: RFC3339 or float unix seconds. Defaults to the server's current time.
-	 */
-	time?: string;
-	/**
-	 * @type string
-	 * @description Evaluation timeout: duration string or float seconds.
-	 */
-	timeout?: string;
-	/**
-	 * @type string
-	 * @description Any non-empty value includes query statistics in the response.
-	 */
-	stats?: string;
-};
-
-export type PrometheusQueryPostParams = {
-	/**
-	 * @type string
-	 * @description PromQL expression.
-	 */
-	query: string;
-	/**
-	 * @type string
-	 * @description Evaluation timestamp: RFC3339 or float unix seconds. Defaults to the server's current time.
-	 */
-	time?: string;
-	/**
-	 * @type string
-	 * @description Evaluation timeout: duration string or float seconds.
-	 */
-	timeout?: string;
-	/**
-	 * @type string
-	 * @description Any non-empty value includes query statistics in the response.
-	 */
-	stats?: string;
-};
-
-export type PrometheusQueryRangeParams = {
-	/**
-	 * @type string
-	 * @description PromQL expression.
-	 */
-	query: string;
-	/**
-	 * @type string
-	 * @description Range start: RFC3339 or float unix seconds.
-	 */
-	start: string;
-	/**
-	 * @type string
-	 * @description Range end: RFC3339 or float unix seconds.
-	 */
-	end: string;
-	/**
-	 * @type string
-	 * @description Resolution step: duration string or float seconds.
-	 */
-	step: string;
-	/**
-	 * @type string
-	 * @description Evaluation timeout: duration string or float seconds.
-	 */
-	timeout?: string;
-	/**
-	 * @type string
-	 * @description Any non-empty value includes query statistics in the response.
-	 */
-	stats?: string;
-};
-
-export type PrometheusQueryRangePostParams = {
-	/**
-	 * @type string
-	 * @description PromQL expression.
-	 */
-	query: string;
-	/**
-	 * @type string
-	 * @description Range start: RFC3339 or float unix seconds.
-	 */
-	start: string;
-	/**
-	 * @type string
-	 * @description Range end: RFC3339 or float unix seconds.
-	 */
-	end: string;
-	/**
-	 * @type string
-	 * @description Resolution step: duration string or float seconds.
-	 */
-	step: string;
-	/**
-	 * @type string
-	 * @description Evaluation timeout: duration string or float seconds.
-	 */
-	timeout?: string;
-	/**
-	 * @type string
-	 * @description Any non-empty value includes query statistics in the response.
-	 */
-	stats?: string;
-};

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

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

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

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

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

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

frontend/src/components/ExplorerCard/MenuItemGenerator.tsx

@@ -57,8 +57,8 @@ function MenuItemGenerator({
 
 			handleExplorerTabChange(currentPanelType, {
 				query,
-				viewName: name,
-				viewKey: id,
+				name,
+				id,
 			});
 		},
 		[viewData, handleExplorerTabChange],

frontend/src/components/RefreshPaymentStatus/RefreshPaymentStatus.tsx

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

frontend/src/constants/events.ts

@@ -29,7 +29,6 @@ export enum InfraMonitoringEvents {
 	MetricsView = 'metrics',
 	Total = 'total',
 	Cluster = 'cluster',
-	Container = 'container',
 	DaemonSet = 'daemonSet',
 	Deployment = 'deployment',
 	Job = 'job',

frontend/src/constants/generated/semconvFamilies.gen.ts

@@ -1,32 +1,82 @@
 // Code generated by scripts/semconv. DO NOT EDIT.
 
-export type SemconvFamily = {
-	readonly current: string;
-	readonly old: readonly string[];
-	readonly kind: 'attribute' | 'metric';
+// An empty contexts/signals/applyToMetrics array places no constraint on
+// that axis.
+export type SemconvMember = {
+	readonly name: string;
 	readonly contexts: readonly string[];
 	readonly signals: readonly string[];
 	readonly applyToMetrics: readonly string[];
+};
+
+export type SemconvFamily = {
+	readonly current: string;
+	readonly kind: 'attribute' | 'metric';
+	readonly members: readonly SemconvMember[];
+	readonly contexts: readonly string[];
+	readonly signals: readonly string[];
 	readonly valueMap: Readonly<Record<string, string>>;
 };
 
 export const SEMCONV_FAMILIES: readonly SemconvFamily[] = [
 	{
-		current: 'db.system.name',
-		old: ['db.system'],
-		kind: 'attribute',
+		current: 'container.cpu.usage',
+		kind: 'metric',
+		members: [
+			{
+				name: 'container.cpu.utilization',
+				contexts: [],
+				signals: [],
+				applyToMetrics: [],
+			},
+		],
 		contexts: [],
 		signals: [],
-		applyToMetrics: [],
 		valueMap: {},
 	},
 	{
 		current: 'deployment.environment.name',
-		old: ['deployment.environment'],
 		kind: 'attribute',
+		members: [
+			{
+				name: 'deployment.environment',
+				contexts: [],
+				signals: [],
+				applyToMetrics: [],
+			},
+		],
+		contexts: ['attribute', 'resource'],
+		signals: ['logs', 'metrics', 'traces'],
+		valueMap: {},
+	},
+	{
+		current: 'k8s.node.cpu.usage',
+		kind: 'metric',
+		members: [
+			{
+				name: 'k8s.node.cpu.utilization',
+				contexts: [],
+				signals: [],
+				applyToMetrics: [],
+			},
+		],
+		contexts: [],
+		signals: [],
+		valueMap: {},
+	},
+	{
+		current: 'k8s.pod.cpu.usage',
+		kind: 'metric',
+		members: [
+			{
+				name: 'k8s.pod.cpu.utilization',
+				contexts: [],
+				signals: [],
+				applyToMetrics: [],
+			},
+		],
 		contexts: [],
 		signals: [],
-		applyToMetrics: [],
 		valueMap: {},
 	},
 ] as const;

frontend/src/constants/reactQueryKeys.ts

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

frontend/src/container/AllAlertChannels/__tests__/CreateAlertChannel.test.tsx

@@ -1,10 +1,6 @@
 import CreateAlertChannels from 'container/CreateAlertChannels';
 import { ChannelType } from 'container/CreateAlertChannels/config';
-import {
-	GoogleChatInitialConfig,
-	JiraInitialConfig,
-	JsmOpsInitialConfig,
-} from 'container/CreateAlertChannels/defaults';
+import { GoogleChatInitialConfig } from 'container/CreateAlertChannels/defaults';
 import {
 	googleChatDescriptionDefaultValue,
 	googleChatTitleDefaultValue,
@@ -530,213 +526,6 @@ describe('Create Alert Channel', () => {
 				});
 			});
 		});
-		describe('Jira', () => {
-			const validSite = 'https://acme.atlassian.net';
-
-			const fillRequired = async (
-				user: ReturnType<typeof userEvent.setup>,
-				site: string,
-			): Promise<void> => {
-				await user.type(screen.getByTestId('channel-name-textbox'), 'jira-channel');
-				await user.type(screen.getByTestId('jira-site-textbox'), site);
-				await user.type(screen.getByTestId('jira-email-textbox'), 'me@acme.com');
-				await user.type(screen.getByTestId('jira-api-token-textbox'), 'tok123');
-				await user.type(screen.getByTestId('jira-project-textbox'), 'KAN');
-			};
-
-			beforeEach(() => {
-				render(<CreateAlertChannels preType={ChannelType.Jira} />);
-			});
-
-			it('Should check if the selected item in the type dropdown has text "Jira"', () => {
-				expect(screen.getByText('Jira')).toBeInTheDocument();
-			});
-
-			it('Should check if the Site URL field is displayed properly', () => {
-				testLabelInputAndHelpValue({
-					labelText: 'field_jira_site',
-					testId: 'jira-site-textbox',
-				});
-			});
-
-			it('Should prefill the issue type with Task', () => {
-				expect(screen.getByTestId('jira-issue-type-textbox')).toHaveValue('Task');
-			});
-
-			it('Should show the service-account recommendation tip linking to the docs', () => {
-				expect(screen.getByTestId('jira-service-account-tip')).toBeInTheDocument();
-				expect(
-					screen.getByRole('link', { name: 'jira_service_account_tip_link' }),
-				).toHaveAttribute(
-					'href',
-					'https://signoz.io/docs/alerts-management/notification-channel/jira/#use-a-service-account-recommended',
-				);
-			});
-
-			it('Should display an error when the site is not an atlassian.net URL', async () => {
-				const user = userEvent.setup({ delay: null });
-				await fillRequired(user, 'https://example.com');
-
-				await user.click(screen.getByTestId('save-channel-button'));
-
-				await waitFor(() =>
-					expect(errorNotification).toHaveBeenCalledWith({
-						message: 'Error',
-						description: 'jira_site_invalid',
-					}),
-				);
-			});
-
-			it('Should send a jira_configs payload with basic auth', async () => {
-				let requestBody: unknown;
-				server.use(
-					rest.post('http://localhost/api/v1/channels', async (req, res, ctx) => {
-						requestBody = await req.json();
-						return res(
-							ctx.status(201),
-							ctx.json({ status: 'success', data: 'channel created' }),
-						);
-					}),
-				);
-
-				const user = userEvent.setup({ delay: null });
-				await fillRequired(user, validSite);
-
-				await user.click(screen.getByTestId('save-channel-button'));
-
-				await waitFor(() =>
-					expect(successNotification).toHaveBeenCalledWith({
-						message: 'Success',
-						description: 'channel_creation_done',
-					}),
-				);
-
-				expect(requestBody).toStrictEqual({
-					name: 'jira-channel',
-					jira_configs: [
-						{
-							site: validSite,
-							project: 'KAN',
-							issue_type: 'Task',
-							summary: JiraInitialConfig.summary,
-							description: JiraInitialConfig.description,
-							send_resolved: true,
-							http_config: {
-								basic_auth: { username: 'me@acme.com', password: 'tok123' },
-							},
-						},
-					],
-				});
-			}, 15000);
-
-			it('Should block save when the reopen window is below the 1m minimum', async () => {
-				const user = userEvent.setup({ delay: null });
-				await fillRequired(user, validSite);
-
-				await user.click(screen.getByText('jira_advanced_section'));
-				await user.type(screen.getByTestId('jira-reopen-duration-textbox'), '30s');
-
-				// the rule surfaces an inline message, not just a red border
-				await expect(
-					screen.findByText('jira_reopen_duration_invalid'),
-				).resolves.toBeInTheDocument();
-
-				await user.click(screen.getByTestId('save-channel-button'));
-
-				await waitFor(() =>
-					expect(errorNotification).toHaveBeenCalledWith({
-						message: 'Error',
-						description: 'jira_reopen_duration_invalid',
-					}),
-				);
-			}, 15000);
-		});
-		describe('JSM Ops', () => {
-			beforeEach(() => {
-				render(<CreateAlertChannels preType={ChannelType.JsmOps} />);
-			});
-
-			it('Should show "Jira Service Management Ops" as the selected type', () => {
-				expect(screen.getByText('Jira Service Management Ops')).toBeInTheDocument();
-			});
-
-			it('Should display the API key field properly', () => {
-				testLabelInputAndHelpValue({
-					labelText: 'field_jsmops_api_key',
-					testId: 'jsmops-api-key-textbox',
-				});
-			});
-
-			it('Should show the tip linking to the JSM Ops docs', () => {
-				expect(screen.getByTestId('jsmops-tip')).toBeInTheDocument();
-				expect(
-					screen.getByRole('link', { name: 'jsmops_tip_link' }),
-				).toHaveAttribute(
-					'href',
-					'https://signoz.io/docs/alerts-management/notification-channel/jsm-ops/',
-				);
-			});
-
-			it('Should block save when the API key is missing', async () => {
-				const user = userEvent.setup();
-				await user.type(
-					screen.getByTestId('channel-name-textbox'),
-					'jsmops-channel',
-				);
-
-				await user.click(screen.getByTestId('save-channel-button'));
-
-				await waitFor(() =>
-					expect(errorNotification).toHaveBeenCalledWith({
-						message: 'Error',
-						description: 'api_key_required',
-					}),
-				);
-			});
-
-			it('Should send a jsmops_configs payload with prefilled defaults', async () => {
-				let requestBody: unknown;
-				server.use(
-					rest.post('http://localhost/api/v1/channels', async (req, res, ctx) => {
-						requestBody = await req.json();
-						return res(
-							ctx.status(201),
-							ctx.json({ status: 'success', data: 'channel created' }),
-						);
-					}),
-				);
-
-				const user = userEvent.setup();
-				await user.type(
-					screen.getByTestId('channel-name-textbox'),
-					'jsmops-channel',
-				);
-				await user.type(screen.getByTestId('jsmops-api-key-textbox'), 'key-abc');
-
-				await user.click(screen.getByTestId('save-channel-button'));
-
-				await waitFor(() =>
-					expect(successNotification).toHaveBeenCalledWith({
-						message: 'Success',
-						description: 'channel_creation_done',
-					}),
-				);
-
-				expect(requestBody).toStrictEqual({
-					name: 'jsmops-channel',
-					jsmops_configs: [
-						{
-							api_key: 'key-abc',
-							send_resolved: true,
-							message: JsmOpsInitialConfig.message,
-							description: JsmOpsInitialConfig.description,
-							priority: JsmOpsInitialConfig.priority,
-							tags: JsmOpsInitialConfig.tags?.join(','),
-						},
-					],
-				});
-			});
-		});
 		describe('Changing the channel type', () => {
 			async function selectType(
 				user: ReturnType<typeof userEvent.setup>,

frontend/src/container/AllAlertChannels/__tests__/EditAlertChannelSave.test.tsx

@@ -58,38 +58,6 @@ describe('EditAlertChannels save', () => {
 		expect(edit.calls[0].id).toBe('3');
 	});
 
-	it('blocks jira save when the reopen window is below the 1m minimum', async () => {
-		const edit = mockEditChannel();
-		const jiraInitialValue = {
-			type: 'jira',
-			name: 'jira-channel',
-			site: 'https://acme.atlassian.net',
-			username: 'user@acme.io',
-			password: 'token',
-			project: 'OPS',
-			issue_type: 'Task',
-			send_resolved: true,
-			reopen_duration: '30s',
-		};
-
-		const { unmount } = render(
-			<EditAlertChannels channelId="3" initialValue={jiraInitialValue} />,
-		);
-		const user = userEvent.setup();
-		await user.click(screen.getByTestId('save-channel-button'));
-		expect(edit.calls).toHaveLength(0);
-		unmount();
-
-		render(
-			<EditAlertChannels
-				channelId="3"
-				initialValue={{ ...jiraInitialValue, reopen_duration: '72h' }}
-			/>,
-		);
-		await user.click(screen.getByTestId('save-channel-button'));
-		await waitFor(() => expect(edit.calls).toHaveLength(1));
-	});
-
 	it('persists send_resolved toggle in the edit request', async () => {
 		const edit = mockEditChannel();
 		render(

frontend/src/container/AppLayout/index.tsx

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

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

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

frontend/src/container/BillingContainer/BillingContainer.tsx

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

frontend/src/container/CreateAlertChannels/config.ts

@@ -105,8 +105,6 @@ export enum ChannelType {
 	Opsgenie = 'opsgenie',
 	MsTeams = 'msteams',
 	GoogleChat = 'googlechat',
-	Jira = 'jira',
-	JsmOps = 'jsmops',
 }
 
 // LabelFilterStatement will be used for preparing filter conditions / matchers
@@ -136,39 +134,3 @@ export interface GoogleChatChannel extends Channel {
 	title?: string;
 	text?: string;
 }
-
-// JiraChannel configures the Jira Cloud alert channel. Auth is basic auth
-// (Atlassian account email + API token) carried in username / password.
-export interface JiraChannel extends Channel {
-	// Jira Cloud base URL, e.g. https://acme.atlassian.net
-	site: string;
-	project: string;
-	issue_type: string;
-	// issue title template
-	summary?: string;
-	// issue body template, rendered to rich text server-side
-	description?: string;
-	// basic auth: username is the Atlassian account email, password is the API token
-	username: string;
-	password: string;
-	priority?: string;
-	labels?: string[];
-	resolve_transition?: string;
-	reopen_transition?: string;
-	// duration string, e.g. 72h or 3d
-	reopen_duration?: string;
-}
-
-// JsmOpsChannel configures the Jira Service Management Ops alert channel
-// (ex-Opsgenie alert API). Auth is the JSM integration API key.
-export interface JsmOpsChannel extends Channel {
-	api_key: string;
-	// alert title template
-	message?: string;
-	// alert body template (markdown, rendered to HTML server-side)
-	description?: string;
-	// priority template, resolves to P1-P5
-	priority?: string;
-	// tags, joined to a comma-separated string for the backend
-	tags?: string[];
-}

frontend/src/container/CreateAlertChannels/defaults.ts

@@ -2,8 +2,6 @@ import {
 	ChannelType,
 	EmailChannel,
 	GoogleChatChannel,
-	JiraChannel,
-	JsmOpsChannel,
 	MsTeamsChannel,
 	OpsgenieChannel,
 	PagerChannel,
@@ -49,23 +47,6 @@ export const GoogleChatInitialConfig: Partial<GoogleChatChannel> = {
 {{ end }}`,
 };
 
-// mirrors DefaultJiraSummaryTemplate / DefaultJiraDescriptionTemplate in
-// pkg/types/alertmanagertypes/jira.go, which the backend applies when the
-// summary / description are left empty. The description is markdown here and is
-// wrapped in the ADF status panel + deep-links server-side.
-export const JiraInitialConfig: Partial<JiraChannel> = {
-	issue_type: 'Task',
-	summary: `[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .CommonLabels.alertname }}`,
-	description: `{{ range .Alerts -}}
-**Alert:** {{ .Labels.alertname }}{{ if .Labels.severity }} ({{ .Labels.severity }}){{ end }}
-{{ if .Annotations.summary }}
-**Summary:** {{ .Annotations.summary }}
-{{ end }}{{ if .Annotations.description }}
-**Description:** {{ .Annotations.description }}
-{{ end }}
-{{ end }}`,
-};
-
 export const PagerInitialConfig: Partial<PagerChannel> = {
 	description: `[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .CommonLabels.alertname }} for {{ .CommonLabels.job }}
 	{{- if gt (len .CommonLabels) (len .GroupLabels) -}}
@@ -117,33 +98,6 @@ export const OpsgenieInitialConfig: Partial<OpsgenieChannel> = {
 		'{{ if eq (index .Alerts 0).Labels.severity "critical" }}P1{{ else if eq (index .Alerts 0).Labels.severity "warning" }}P2{{ else if eq (index .Alerts 0).Labels.severity "info" }}P3{{ else }}P4{{ end }}',
 };
 
-// mirrors DefaultJSMOpsMessageTemplate / DefaultJSMOpsDescriptionTemplate in
-// pkg/types/alertmanagertypes/jsmops.go, applied by the backend when message /
-// description are left empty. send_resolved is seeded on so JSM alerts close on
-// resolve (the backend cannot default it, see jsmops.go). priority mirrors the
-// Opsgenie template mapping severity to P1-P5.
-export const JsmOpsInitialConfig: Partial<JsmOpsChannel> = {
-	send_resolved: true,
-	message: `[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .CommonLabels.alertname }}`,
-	description: `{{ range .Alerts -}}
-**Alert:** {{ .Labels.alertname }}{{ if .Labels.severity }} ({{ .Labels.severity }}){{ end }}
-
-{{ if .Annotations.summary }}**Summary:** {{ .Annotations.summary }}
-
-{{ end }}{{ if .Annotations.description }}**Description:** {{ .Annotations.description }}
-
-{{ end }}{{ if .GeneratorURL }}[View in SigNoz]({{ .GeneratorURL }})
-
-{{ end }}{{ if .Annotations.related_logs }}[View related logs]({{ .Annotations.related_logs }})
-
-{{ end }}{{ if .Annotations.related_traces }}[View related traces]({{ .Annotations.related_traces }})
-
-{{ end }}{{ end }}`,
-	priority:
-		'{{ if eq (index .Alerts 0).Labels.severity "critical" }}P1{{ else if eq (index .Alerts 0).Labels.severity "warning" }}P2{{ else if eq (index .Alerts 0).Labels.severity "info" }}P3{{ else }}P4{{ end }}',
-	tags: ['signoz-alert'],
-};
-
 export const EmailInitialConfig: Partial<EmailChannel> = {
 	send_resolved: true,
 	html: `<!--
@@ -551,16 +505,12 @@ export const ChannelInitialConfig: Record<
 			MsTeamsChannel &
 			OpsgenieChannel &
 			EmailChannel &
-			GoogleChatChannel &
-			JiraChannel &
-			JsmOpsChannel
+			GoogleChatChannel
 	>
 > = {
 	[ChannelType.Slack]: SlackInitialConfig,
 	[ChannelType.MsTeams]: SlackInitialConfig,
 	[ChannelType.GoogleChat]: GoogleChatInitialConfig,
-	[ChannelType.Jira]: JiraInitialConfig,
-	[ChannelType.JsmOps]: JsmOpsInitialConfig,
 	[ChannelType.Pagerduty]: PagerInitialConfig,
 	[ChannelType.Opsgenie]: OpsgenieInitialConfig,
 	[ChannelType.Email]: EmailInitialConfig,

frontend/src/container/CreateAlertChannels/index.tsx

@@ -32,8 +32,6 @@ import {
 	ChannelType,
 	EmailChannel,
 	GoogleChatChannel,
-	JiraChannel,
-	JsmOpsChannel,
 	MsTeamsChannel,
 	OpsgenieChannel,
 	PagerChannel,
@@ -45,11 +43,7 @@ import { ChannelInitialConfig } from './defaults';
 import {
 	isChannelType,
 	isValidGoogleChatWebhookURL,
-	isValidJiraReopenDuration,
-	isValidJiraSiteURL,
 	prepareGoogleChatRequest,
-	prepareJiraRequest,
-	prepareJsmOpsRequest,
 } from './utils';
 
 import './CreateAlertChannels.styles.scss';
@@ -75,9 +69,7 @@ function CreateAlertChannels({
 				MsTeamsChannel &
 				OpsgenieChannel &
 				EmailChannel &
-				GoogleChatChannel &
-				JiraChannel &
-				JsmOpsChannel
+				GoogleChatChannel
 		>
 	>(() => ({
 		send_resolved: true,
@@ -442,114 +434,6 @@ function CreateAlertChannels({
 		showErrorModal,
 	]);
 
-	const validateJiraConfig = useCallback((): boolean => {
-		if (
-			!selectedConfig.site ||
-			!selectedConfig.username ||
-			!selectedConfig.password ||
-			!selectedConfig.project ||
-			!selectedConfig.issue_type
-		) {
-			notifications.error({
-				message: 'Error',
-				description: t('jira_required_fields'),
-			});
-			return false;
-		}
-
-		if (!isValidJiraSiteURL(selectedConfig.site)) {
-			notifications.error({
-				message: 'Error',
-				description: t('jira_site_invalid'),
-			});
-			return false;
-		}
-
-		if (
-			selectedConfig.reopen_duration &&
-			!isValidJiraReopenDuration(selectedConfig.reopen_duration)
-		) {
-			notifications.error({
-				message: 'Error',
-				description: t('jira_reopen_duration_invalid'),
-			});
-			return false;
-		}
-
-		return true;
-	}, [selectedConfig, notifications, t]);
-
-	const onJiraHandler = useCallback(async () => {
-		if (!validateJiraConfig()) {
-			return { status: 'failed', statusMessage: t('channel_creation_failed') };
-		}
-
-		setSavingState(true);
-
-		try {
-			await createChannel({ data: prepareJiraRequest(selectedConfig) });
-			notifications.success({
-				message: 'Success',
-				description: t('channel_creation_done'),
-			});
-			history.replace(ROUTES.ALL_CHANNELS);
-			return { status: 'success', statusMessage: t('channel_creation_done') };
-		} catch (error) {
-			showErrorModal(toAPIError(error as ErrorType<RenderErrorResponseDTO>));
-			return { status: 'failed', statusMessage: t('channel_creation_failed') };
-		} finally {
-			setSavingState(false);
-		}
-	}, [
-		validateJiraConfig,
-		createChannel,
-		selectedConfig,
-		notifications,
-		t,
-		showErrorModal,
-	]);
-
-	const validateJsmOpsConfig = useCallback((): boolean => {
-		if (!selectedConfig.api_key) {
-			notifications.error({
-				message: 'Error',
-				description: t('api_key_required'),
-			});
-			return false;
-		}
-		return true;
-	}, [selectedConfig.api_key, notifications, t]);
-
-	const onJsmOpsHandler = useCallback(async () => {
-		if (!validateJsmOpsConfig()) {
-			return { status: 'failed', statusMessage: t('channel_creation_failed') };
-		}
-
-		setSavingState(true);
-
-		try {
-			await createChannel({ data: prepareJsmOpsRequest(selectedConfig) });
-			notifications.success({
-				message: 'Success',
-				description: t('channel_creation_done'),
-			});
-			history.replace(ROUTES.ALL_CHANNELS);
-			return { status: 'success', statusMessage: t('channel_creation_done') };
-		} catch (error) {
-			showErrorModal(toAPIError(error as ErrorType<RenderErrorResponseDTO>));
-			return { status: 'failed', statusMessage: t('channel_creation_failed') };
-		} finally {
-			setSavingState(false);
-		}
-	}, [
-		validateJsmOpsConfig,
-		createChannel,
-		selectedConfig,
-		notifications,
-		t,
-		showErrorModal,
-	]);
-
 	const onSaveHandler = useCallback(
 		async (value: ChannelType) => {
 			if (!selectedConfig.name) {
@@ -568,8 +452,6 @@ function CreateAlertChannels({
 				[ChannelType.MsTeams]: onMsTeamsHandler,
 				[ChannelType.Email]: onEmailHandler,
 				[ChannelType.GoogleChat]: onGoogleChatHandler,
-				[ChannelType.Jira]: onJiraHandler,
-				[ChannelType.JsmOps]: onJsmOpsHandler,
 			};
 
 			if (isChannelType(value)) {
@@ -602,8 +484,6 @@ function CreateAlertChannels({
 			onMsTeamsHandler,
 			onEmailHandler,
 			onGoogleChatHandler,
-			onJiraHandler,
-			onJsmOpsHandler,
 			notifications,
 			t,
 		],
@@ -648,20 +528,6 @@ function CreateAlertChannels({
 						}
 						await testChannel({ data: prepareGoogleChatRequest(selectedConfig) });
 						break;
-					case ChannelType.Jira:
-						if (!validateJiraConfig()) {
-							setTestingState(false);
-							return;
-						}
-						await testChannel({ data: prepareJiraRequest(selectedConfig) });
-						break;
-					case ChannelType.JsmOps:
-						if (!validateJsmOpsConfig()) {
-							setTestingState(false);
-							return;
-						}
-						await testChannel({ data: prepareJsmOpsRequest(selectedConfig) });
-						break;
 					default:
 						notifications.error({
 							message: 'Error',
@@ -710,8 +576,6 @@ function CreateAlertChannels({
 			prepareMsTeamsRequest,
 			prepareEmailRequest,
 			validateGoogleChatConfig,
-			validateJiraConfig,
-			validateJsmOpsConfig,
 			testChannel,
 			notifications,
 		],

frontend/src/container/CreateAlertChannels/utils.ts

@@ -1,17 +1,9 @@
 import {
-	AlertmanagertypesJiraReceiverConfigDTO,
-	AlertmanagertypesJSMOpsReceiverConfigDTO,
 	AlertmanagertypesPostableChannelDTO,
 	ConfigSecretURLDTO,
-	ModelDurationDTO,
 } from 'api/generated/services/sigNoz.schemas';
 
-import {
-	ChannelType,
-	GoogleChatChannel,
-	JiraChannel,
-	JsmOpsChannel,
-} from './config';
+import { ChannelType, GoogleChatChannel } from './config';
 
 export const isChannelType = (type: string): type is ChannelType =>
 	Object.values(ChannelType).includes(type as ChannelType);
@@ -45,126 +37,3 @@ export const prepareGoogleChatRequest = (
 		},
 	],
 });
-
-const JIRA_CLOUD_HOST_SUFFIX = '.atlassian.net';
-
-// the backend enforces the same rule, this is only for a nicer error experience
-export const isValidJiraSiteURL = (url: string): boolean => {
-	try {
-		const { protocol, hostname } = new URL(url);
-		return (
-			protocol === 'https:' &&
-			hostname.toLowerCase().endsWith(JIRA_CLOUD_HOST_SUFFIX)
-		);
-	} catch {
-		return false;
-	}
-};
-
-// mirrors go's prometheus model.Duration units
-const JIRA_DURATION_UNIT_MS: Record<string, number> = {
-	ms: 1,
-	s: 1_000,
-	m: 60_000,
-	h: 3_600_000,
-	d: 86_400_000,
-	w: 604_800_000,
-	y: 31_536_000_000,
-};
-const JIRA_DURATION_RE = /^(\d+(ms|s|m|h|d|w|y))+$/;
-const JIRA_DURATION_TOKEN_RE = /(\d+)(ms|s|m|h|d|w|y)/g;
-const JIRA_MIN_REOPEN_MS = 60_000;
-
-// backend requires the same format and a >= 1m minimum, this is only for a
-// nicer error experience. Empty and "0" defer to the backend default.
-export const isValidJiraReopenDuration = (value: string): boolean => {
-	if (!value || value === '0') {
-		return true;
-	}
-	if (!JIRA_DURATION_RE.test(value)) {
-		return false;
-	}
-	let totalMs = 0;
-	for (const [, amount, unit] of value.matchAll(JIRA_DURATION_TOKEN_RE)) {
-		totalMs += Number(amount) * JIRA_DURATION_UNIT_MS[unit];
-	}
-	return totalMs >= JIRA_MIN_REOPEN_MS;
-};
-
-// create, update and test all send the same body shape. Optional fields are
-// omitted when empty so the backend applies its defaults.
-export const prepareJiraRequest = (
-	config: Partial<JiraChannel>,
-): AlertmanagertypesPostableChannelDTO => {
-	const jira: AlertmanagertypesJiraReceiverConfigDTO = {
-		site: config.site || '',
-		project: config.project || '',
-		issue_type: config.issue_type || '',
-		send_resolved: config.send_resolved || false,
-		http_config: {
-			basic_auth: {
-				username: config.username || '',
-				password: config.password || '',
-			},
-		},
-	};
-
-	if (config.summary) {
-		jira.summary = config.summary;
-	}
-	if (config.description) {
-		jira.description = config.description;
-	}
-	if (config.priority) {
-		jira.priority = config.priority;
-	}
-	if (config.labels?.length) {
-		jira.labels = config.labels;
-	}
-	if (config.resolve_transition) {
-		jira.resolve_transition = config.resolve_transition;
-	}
-	if (config.reopen_transition) {
-		jira.reopen_transition = config.reopen_transition;
-	}
-	if (config.reopen_duration) {
-		// the generated type models go's model.Duration as a number, the api takes a
-		// duration string like "72h"
-		jira.reopen_duration = config.reopen_duration as unknown as ModelDurationDTO;
-	}
-
-	return {
-		name: config.name || '',
-		jira_configs: [jira],
-	};
-};
-
-// create, update and test all send the same body shape. Optional fields are
-// omitted when empty so the backend applies its defaults.
-export const prepareJsmOpsRequest = (
-	config: Partial<JsmOpsChannel>,
-): AlertmanagertypesPostableChannelDTO => {
-	const jsmops: AlertmanagertypesJSMOpsReceiverConfigDTO = {
-		api_key: config.api_key || '',
-		send_resolved: config.send_resolved || false,
-	};
-
-	if (config.message) {
-		jsmops.message = config.message;
-	}
-	if (config.description) {
-		jsmops.description = config.description;
-	}
-	if (config.priority) {
-		jsmops.priority = config.priority;
-	}
-	if (config.tags?.length) {
-		// the backend takes a comma-separated string and splits it back
-		jsmops.tags = config.tags.join(',');
-	}
-
-	return {
-		name: config.name || '',
-		jsmops_configs: [jsmops],
-	};
-};

frontend/src/container/EditAlertChannels/index.tsx

@@ -25,8 +25,6 @@ import {
 	ChannelType,
 	EmailChannel,
 	GoogleChatChannel,
-	JiraChannel,
-	JsmOpsChannel,
 	MsTeamsChannel,
 	OpsgenieChannel,
 	PagerChannel,
@@ -36,11 +34,7 @@ import {
 } from 'container/CreateAlertChannels/config';
 import {
 	isValidGoogleChatWebhookURL,
-	isValidJiraReopenDuration,
-	isValidJiraSiteURL,
 	prepareGoogleChatRequest,
-	prepareJiraRequest,
-	prepareJsmOpsRequest,
 } from 'container/CreateAlertChannels/utils';
 import FormAlertChannels from 'container/FormAlertChannels';
 import { useNotifications } from 'hooks/useNotifications';
@@ -64,9 +58,7 @@ function EditAlertChannels({
 				MsTeamsChannel &
 				OpsgenieChannel &
 				EmailChannel &
-				GoogleChatChannel &
-				JiraChannel &
-				JsmOpsChannel
+				GoogleChatChannel
 		>
 	>({
 		...initialValue,
@@ -460,124 +452,6 @@ function EditAlertChannels({
 		t,
 	]);
 
-	const validateJiraConfig = useCallback((): string => {
-		if (
-			!selectedConfig.site ||
-			!selectedConfig.username ||
-			!selectedConfig.password ||
-			!selectedConfig.project ||
-			!selectedConfig.issue_type
-		) {
-			return t('jira_required_fields');
-		}
-
-		if (!isValidJiraSiteURL(selectedConfig.site)) {
-			return t('jira_site_invalid');
-		}
-
-		if (
-			selectedConfig.reopen_duration &&
-			!isValidJiraReopenDuration(selectedConfig.reopen_duration)
-		) {
-			return t('jira_reopen_duration_invalid');
-		}
-
-		return '';
-	}, [selectedConfig, t]);
-
-	const onJiraEditHandler = useCallback(async () => {
-		const validationError = validateJiraConfig();
-
-		if (validationError !== '') {
-			notifications.error({
-				message: 'Error',
-				description: validationError,
-			});
-			return { status: 'failed', statusMessage: validationError };
-		}
-
-		setSavingState(true);
-
-		try {
-			await updateChannel({
-				pathParams: { id },
-				data: prepareJiraRequest(selectedConfig),
-			});
-			notifications.success({
-				message: 'Success',
-				description: t('channel_edit_done'),
-			});
-			history.replace(ROUTES.ALL_CHANNELS);
-			return { status: 'success', statusMessage: t('channel_edit_done') };
-		} catch (error) {
-			const apiError = notifyError(error);
-			return {
-				status: 'failed',
-				statusMessage: apiError.getErrorMessage() || t('channel_edit_failed'),
-			};
-		} finally {
-			setSavingState(false);
-		}
-	}, [
-		validateJiraConfig,
-		updateChannel,
-		id,
-		selectedConfig,
-		notifications,
-		notifyError,
-		t,
-	]);
-
-	const validateJsmOpsConfig = useCallback((): string => {
-		if (!selectedConfig.api_key) {
-			return t('api_key_required');
-		}
-		return '';
-	}, [selectedConfig, t]);
-
-	const onJsmOpsEditHandler = useCallback(async () => {
-		const validationError = validateJsmOpsConfig();
-
-		if (validationError !== '') {
-			notifications.error({
-				message: 'Error',
-				description: validationError,
-			});
-			return { status: 'failed', statusMessage: validationError };
-		}
-
-		setSavingState(true);
-
-		try {
-			await updateChannel({
-				pathParams: { id },
-				data: prepareJsmOpsRequest(selectedConfig),
-			});
-			notifications.success({
-				message: 'Success',
-				description: t('channel_edit_done'),
-			});
-			history.replace(ROUTES.ALL_CHANNELS);
-			return { status: 'success', statusMessage: t('channel_edit_done') };
-		} catch (error) {
-			const apiError = notifyError(error);
-			return {
-				status: 'failed',
-				statusMessage: apiError.getErrorMessage() || t('channel_edit_failed'),
-			};
-		} finally {
-			setSavingState(false);
-		}
-	}, [
-		validateJsmOpsConfig,
-		updateChannel,
-		id,
-		selectedConfig,
-		notifications,
-		notifyError,
-		t,
-	]);
-
 	const onSaveHandler = useCallback(
 		async (value: ChannelType) => {
 			let result;
@@ -595,10 +469,6 @@ function EditAlertChannels({
 				result = await onEmailEditHandler();
 			} else if (value === ChannelType.GoogleChat) {
 				result = await onGoogleChatEditHandler();
-			} else if (value === ChannelType.Jira) {
-				result = await onJiraEditHandler();
-			} else if (value === ChannelType.JsmOps) {
-				result = await onJsmOpsEditHandler();
 			}
 			logEvent('Alert Channel: Save channel', {
 				type: value,
@@ -618,13 +488,10 @@ function EditAlertChannels({
 			onOpsgenieEditHandler,
 			onEmailEditHandler,
 			onGoogleChatEditHandler,
-			onJiraEditHandler,
-			onJsmOpsEditHandler,
 		],
 	);
 
 	const performChannelTest = useCallback(
-		// eslint-disable-next-line sonarjs/cognitive-complexity
 		async (channelType: ChannelType) => {
 			setTestingState(true);
 			try {
@@ -675,32 +542,6 @@ function EditAlertChannels({
 						await testChannel({ data: prepareGoogleChatRequest(selectedConfig) });
 						break;
 					}
-					case ChannelType.Jira: {
-						const validationError = validateJiraConfig();
-						if (validationError !== '') {
-							notifications.error({
-								message: 'Error',
-								description: validationError,
-							});
-							setTestingState(false);
-							return;
-						}
-						await testChannel({ data: prepareJiraRequest(selectedConfig) });
-						break;
-					}
-					case ChannelType.JsmOps: {
-						const validationError = validateJsmOpsConfig();
-						if (validationError !== '') {
-							notifications.error({
-								message: 'Error',
-								description: validationError,
-							});
-							setTestingState(false);
-							return;
-						}
-						await testChannel({ data: prepareJsmOpsRequest(selectedConfig) });
-						break;
-					}
 					default:
 						notifications.error({
 							message: 'Error',
@@ -738,8 +579,6 @@ function EditAlertChannels({
 			t,
 			notifyError,
 			validateGoogleChatConfig,
-			validateJiraConfig,
-			validateJsmOpsConfig,
 			testChannel,
 			prepareWebhookRequest,
 			preparePagerRequest,

frontend/src/container/ExplorerOptions/ExplorerOptions.tsx

@@ -452,15 +452,15 @@ function ExplorerOptions({
 			if (handleChangeSelectedView) {
 				handleChangeSelectedView(panelTypeToExplorerView[currentPanelType], {
 					query,
-					viewName: name,
-					viewKey: id,
+					name,
+					id,
 				});
 			} else {
 				// to remove this after traces cleanup
 				handleExplorerTabChange(currentPanelType, {
 					query,
-					viewName: name,
-					viewKey: id,
+					name,
+					id,
 				});
 			}
 		},

frontend/src/container/FormAlertChannels/Settings/Jira.tsx

@@ -1,242 +0,0 @@
-import { Dispatch, SetStateAction } from 'react';
-import { useTranslation } from 'react-i18next';
-import { Collapse, Form, Input, Select } from 'antd';
-import { Typography } from '@signozhq/ui/typography';
-import { MarkdownRenderer } from 'components/MarkdownRenderer/MarkdownRenderer';
-
-import { JiraChannel } from '../../CreateAlertChannels/config';
-import {
-	isValidJiraReopenDuration,
-	isValidJiraSiteURL,
-} from '../../CreateAlertChannels/utils';
-
-function JiraSettings({ setSelectedConfig }: JiraProps): JSX.Element {
-	const { t } = useTranslation('channels');
-
-	const update = (patch: Partial<JiraChannel>): void =>
-		setSelectedConfig((value) => ({ ...value, ...patch }));
-
-	const advanced = (
-		<>
-			<Form.Item
-				name="priority"
-				label={t('field_jira_priority')}
-				help={t('help_jira_priority')}
-			>
-				<Input
-					placeholder={t('placeholder_jira_priority')}
-					onChange={(event): void => update({ priority: event.target.value })}
-					data-testid="jira-priority-textbox"
-				/>
-			</Form.Item>
-
-			<Form.Item
-				name="labels"
-				label={t('field_jira_labels')}
-				help={t('help_jira_labels')}
-			>
-				<Select
-					mode="tags"
-					open={false}
-					placeholder={t('placeholder_jira_labels')}
-					onChange={(value): void => update({ labels: value as string[] })}
-					data-testid="jira-labels-select"
-				/>
-			</Form.Item>
-
-			<Form.Item
-				name="resolve_transition"
-				label={t('field_jira_resolve_transition')}
-				help={t('help_jira_resolve_transition')}
-			>
-				<Input
-					placeholder={t('placeholder_jira_resolve_transition')}
-					onChange={(event): void =>
-						update({ resolve_transition: event.target.value })
-					}
-					data-testid="jira-resolve-transition-textbox"
-				/>
-			</Form.Item>
-
-			<Form.Item
-				name="reopen_transition"
-				label={t('field_jira_reopen_transition')}
-				help={t('help_jira_reopen_transition')}
-			>
-				<Input
-					placeholder={t('placeholder_jira_reopen_transition')}
-					onChange={(event): void =>
-						update({ reopen_transition: event.target.value })
-					}
-					data-testid="jira-reopen-transition-textbox"
-				/>
-			</Form.Item>
-
-			<Form.Item
-				name="reopen_duration"
-				label={t('field_jira_reopen_duration')}
-				extra={t('help_jira_reopen_duration')}
-				rules={[
-					{
-						validator: (_, value: string): Promise<void> =>
-							isValidJiraReopenDuration(value)
-								? Promise.resolve()
-								: Promise.reject(new Error(t('jira_reopen_duration_invalid'))),
-					},
-				]}
-				tooltip={{
-					title: (
-						<MarkdownRenderer
-							markdownContent={t('tooltip_jira_reopen_duration')}
-							variables={{}}
-						/>
-					),
-					overlayInnerStyle: { maxWidth: 400 },
-					placement: 'right',
-				}}
-			>
-				<Input
-					placeholder={t('placeholder_jira_reopen_duration')}
-					onChange={(event): void => update({ reopen_duration: event.target.value })}
-					data-testid="jira-reopen-duration-textbox"
-				/>
-			</Form.Item>
-		</>
-	);
-
-	return (
-		<>
-			<Typography.Text
-				color="muted"
-				size="sm"
-				testId="jira-service-account-tip"
-				style={{ display: 'block', marginBottom: 16 }}
-			>
-				{t('jira_service_account_tip')}{' '}
-				<Typography.Link
-					href="https://signoz.io/docs/alerts-management/notification-channel/jira/#use-a-service-account-recommended"
-					target="_blank"
-					rel="noopener noreferrer"
-				>
-					{t('jira_service_account_tip_link')}
-				</Typography.Link>
-			</Typography.Text>
-
-			<Form.Item
-				name="site"
-				label={t('field_jira_site')}
-				required
-				rules={[
-					{
-						validator: (_, value: string): Promise<void> =>
-							!value || isValidJiraSiteURL(value)
-								? Promise.resolve()
-								: Promise.reject(new Error(t('jira_site_invalid'))),
-					},
-				]}
-				tooltip={{
-					title: (
-						<MarkdownRenderer
-							markdownContent={t('tooltip_jira_site')}
-							variables={{}}
-						/>
-					),
-					overlayInnerStyle: { maxWidth: 400 },
-					placement: 'right',
-				}}
-			>
-				<Input
-					placeholder="https://your-domain.atlassian.net"
-					onChange={(event): void => update({ site: event.target.value })}
-					data-testid="jira-site-textbox"
-				/>
-			</Form.Item>
-
-			<Form.Item
-				name="username"
-				label={t('field_jira_email')}
-				help={t('help_jira_email')}
-				required
-			>
-				<Input
-					onChange={(event): void => update({ username: event.target.value })}
-					data-testid="jira-email-textbox"
-				/>
-			</Form.Item>
-
-			<Form.Item
-				name="password"
-				label={t('field_jira_api_token')}
-				help={t('help_jira_api_token')}
-				required
-			>
-				<Input
-					type="password"
-					onChange={(event): void => update({ password: event.target.value })}
-					data-testid="jira-api-token-textbox"
-				/>
-			</Form.Item>
-
-			<Form.Item name="project" label={t('field_jira_project')} required>
-				<Input
-					placeholder="e.g. OPS"
-					onChange={(event): void => update({ project: event.target.value })}
-					data-testid="jira-project-textbox"
-				/>
-			</Form.Item>
-
-			<Form.Item
-				name="issue_type"
-				label={t('field_jira_issue_type')}
-				help={t('help_jira_issue_type')}
-				required
-			>
-				<Input
-					onChange={(event): void => update({ issue_type: event.target.value })}
-					data-testid="jira-issue-type-textbox"
-				/>
-			</Form.Item>
-
-			<Form.Item
-				name="summary"
-				label={t('field_jira_summary')}
-				help={t('help_jira_summary')}
-			>
-				<Input.TextArea
-					rows={2}
-					onChange={(event): void => update({ summary: event.target.value })}
-					data-testid="jira-summary-textarea"
-				/>
-			</Form.Item>
-
-			<Form.Item
-				name="description"
-				label={t('field_jira_description')}
-				help={t('help_jira_description')}
-			>
-				<Input.TextArea
-					rows={6}
-					onChange={(event): void => update({ description: event.target.value })}
-					data-testid="jira-description-textarea"
-				/>
-			</Form.Item>
-
-			<Collapse
-				ghost
-				items={[
-					{
-						key: 'advanced',
-						label: t('jira_advanced_section'),
-						children: advanced,
-					},
-				]}
-			/>
-		</>
-	);
-}
-
-interface JiraProps {
-	setSelectedConfig: Dispatch<SetStateAction<Partial<JiraChannel>>>;
-}
-
-export default JiraSettings;

frontend/src/container/FormAlertChannels/Settings/JsmOps.tsx

@@ -1,117 +0,0 @@
-import { Dispatch, SetStateAction } from 'react';
-import { useTranslation } from 'react-i18next';
-import { Collapse, Form, Input, Select } from 'antd';
-import { Typography } from '@signozhq/ui/typography';
-
-import { JsmOpsChannel } from '../../CreateAlertChannels/config';
-
-function JsmOpsSettings({ setSelectedConfig }: JsmOpsProps): JSX.Element {
-	const { t } = useTranslation('channels');
-
-	const update = (patch: Partial<JsmOpsChannel>): void =>
-		setSelectedConfig((value) => ({ ...value, ...patch }));
-
-	const advanced = (
-		<>
-			<Form.Item
-				name="priority"
-				label={t('field_jsmops_priority')}
-				help={t('help_jsmops_priority')}
-			>
-				<Input.TextArea
-					rows={2}
-					onChange={(event): void => update({ priority: event.target.value })}
-					data-testid="jsmops-priority-textarea"
-				/>
-			</Form.Item>
-
-			<Form.Item
-				name="tags"
-				label={t('field_jsmops_tags')}
-				help={t('help_jsmops_tags')}
-			>
-				<Select
-					mode="tags"
-					open={false}
-					placeholder={t('placeholder_jsmops_tags')}
-					onChange={(value): void => update({ tags: value as string[] })}
-					data-testid="jsmops-tags-select"
-				/>
-			</Form.Item>
-		</>
-	);
-
-	return (
-		<>
-			<Typography.Text
-				color="muted"
-				size="sm"
-				testId="jsmops-tip"
-				style={{ display: 'block', marginBottom: 16 }}
-			>
-				{t('jsmops_tip')}{' '}
-				<Typography.Link
-					href="https://signoz.io/docs/alerts-management/notification-channel/jsm-ops/"
-					target="_blank"
-					rel="noopener noreferrer"
-				>
-					{t('jsmops_tip_link')}
-				</Typography.Link>
-			</Typography.Text>
-
-			<Form.Item
-				name="api_key"
-				label={t('field_jsmops_api_key')}
-				help={t('help_jsmops_api_key')}
-				required
-			>
-				<Input
-					type="password"
-					onChange={(event): void => update({ api_key: event.target.value })}
-					data-testid="jsmops-api-key-textbox"
-				/>
-			</Form.Item>
-
-			<Form.Item
-				name="message"
-				label={t('field_jsmops_message')}
-				help={t('help_jsmops_message')}
-			>
-				<Input.TextArea
-					rows={2}
-					onChange={(event): void => update({ message: event.target.value })}
-					data-testid="jsmops-message-textarea"
-				/>
-			</Form.Item>
-
-			<Form.Item
-				name="description"
-				label={t('field_jsmops_description')}
-				help={t('help_jsmops_description')}
-			>
-				<Input.TextArea
-					rows={6}
-					onChange={(event): void => update({ description: event.target.value })}
-					data-testid="jsmops-description-textarea"
-				/>
-			</Form.Item>
-
-			<Collapse
-				ghost
-				items={[
-					{
-						key: 'advanced',
-						label: t('jsmops_advanced_section'),
-						children: advanced,
-					},
-				]}
-			/>
-		</>
-	);
-}
-
-interface JsmOpsProps {
-	setSelectedConfig: Dispatch<SetStateAction<Partial<JsmOpsChannel>>>;
-}
-
-export default JsmOpsSettings;

frontend/src/container/FormAlertChannels/index.tsx

@@ -10,8 +10,6 @@ import {
 	ChannelType,
 	EmailChannel,
 	GoogleChatChannel,
-	JiraChannel,
-	JsmOpsChannel,
 	OpsgenieChannel,
 	PagerChannel,
 	SlackChannel,
@@ -21,8 +19,6 @@ import history from 'lib/history';
 
 import EmailSettings from './Settings/Email';
 import GoogleChatSettings from './Settings/GoogleChat';
-import JiraSettings from './Settings/Jira';
-import JsmOpsSettings from './Settings/JsmOps';
 import MsTeamsSettings from './Settings/MsTeams';
 import OpsgenieSettings from './Settings/Opsgenie';
 import PagerSettings from './Settings/Pager';
@@ -57,10 +53,6 @@ function FormAlertChannels({
 				return <MsTeamsSettings setSelectedConfig={setSelectedConfig} />;
 			case ChannelType.GoogleChat:
 				return <GoogleChatSettings setSelectedConfig={setSelectedConfig} />;
-			case ChannelType.Jira:
-				return <JiraSettings setSelectedConfig={setSelectedConfig} />;
-			case ChannelType.JsmOps:
-				return <JsmOpsSettings setSelectedConfig={setSelectedConfig} />;
 			case ChannelType.Opsgenie:
 				return <OpsgenieSettings setSelectedConfig={setSelectedConfig} />;
 			case ChannelType.Email:
@@ -149,14 +141,6 @@ function FormAlertChannels({
 						>
 							Google Chat
 						</Select.Option>
-
-						<Select.Option value="jira" key="jira" data-testid="select-option">
-							Jira
-						</Select.Option>
-
-						<Select.Option value="jsmops" key="jsmops" data-testid="select-option">
-							Jira Service Management Ops
-						</Select.Option>
 					</Select>
 				</Form.Item>
 
@@ -205,9 +189,7 @@ interface FormAlertChannelsProps {
 					PagerChannel &
 					OpsgenieChannel &
 					EmailChannel &
-					GoogleChatChannel &
-					JiraChannel &
-					JsmOpsChannel
+					GoogleChatChannel
 			>
 		>
 	>;

frontend/src/container/GeneralSettings/GeneralSettings.tsx

@@ -16,8 +16,6 @@ import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { useNotifications } from 'hooks/useNotifications';
 import { StatusCodes } from 'http-status-codes';
 import find from 'lodash-es/find';
-import { AuthZGuardContent } from 'lib/authz/components/AuthZGuard/AuthZGuardContent';
-import { buildLicenseReadPermission } from 'lib/authz/hooks/useAuthZ/permissions/license.permissions';
 import { useAppContext } from 'providers/App/App';
 import {
 	ErrorResponse,
@@ -675,21 +673,17 @@ function GeneralSettings({
 				</span>
 			</div>
 
-			{(showCustomDomainSettings || activeLicense) && (
+			{(showCustomDomainSettings || activeLicense?.key) && (
 				<div className="custom-domain-card">
 					{showCustomDomainSettings && <CustomDomainSettings />}
-					{showCustomDomainSettings && activeLicense && (
+					{showCustomDomainSettings && activeLicense?.key && (
 						<div className="custom-domain-card-divider" />
 					)}
-					{activeLicense && (
-						<AuthZGuardContent
-							checks={[buildLicenseReadPermission(activeLicense.id)]}
-						>
-							<>
-								<LicenseKeyRow />
-								<LicenseRowDismissibleCallout />
-							</>
-						</AuthZGuardContent>
+					{activeLicense?.key && (
+						<>
+							<LicenseKeyRow />
+							<LicenseRowDismissibleCallout />
+						</>
 					)}
 				</div>
 			)}

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

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

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

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

frontend/src/container/Home/SavedViews/SavedViews.tsx

@@ -115,8 +115,8 @@ export default function SavedViews({
 				currentPanelType,
 				{
 					query,
-					viewName: name,
-					viewKey: id,
+					name,
+					id,
 				},
 				SOURCEPAGE_VS_ROUTES[selectedEntity],
 			);

frontend/src/container/InfraMonitoringK8sV2/Base/ColumnHeader.tsx

@@ -4,9 +4,8 @@ import { TooltipSimple } from '@signozhq/ui/tooltip';
 import styles from './ColumnHeader.module.scss';
 import cx from 'classnames';
 import { MouseEventHandler } from 'react';
-import { DOCS_BASE_URL } from 'constants/app';
 
-const DOCS_ROOT = `${DOCS_BASE_URL}/docs`;
+const DOCS_BASE_URL = `${process.env.DOCS_BASE_URL}/docs`;
 
 interface ColumnHeaderProps {
 	children?: React.ReactNode;
@@ -44,7 +43,7 @@ function ColumnHeader({
 						<div onClick={stopPropagationHandler}>
 							{tooltipTitle}{' '}
 							<a
-								href={`${DOCS_ROOT}${docPath}`}
+								href={`${DOCS_BASE_URL}${docPath}`}
 								target="_blank"
 								rel="noopener"
 								onClick={stopPropagationHandler}

frontend/src/container/InfraMonitoringK8sV2/Base/EntityGroupHeader.module.scss

@@ -2,6 +2,7 @@
 	display: flex;
 	align-items: center;
 	gap: var(--spacing-5);
+	padding-left: 4px;
 }
 
 .infoIcon {

frontend/src/container/InfraMonitoringK8sV2/Base/EntityGroupHeader.tsx

@@ -2,9 +2,8 @@ import { Group, Info } from '@signozhq/icons';
 import { TooltipSimple } from '@signozhq/ui/tooltip';
 
 import styles from './EntityGroupHeader.module.scss';
-import { DOCS_BASE_URL } from 'constants/app';
 
-const DOCS_ROOT = `${DOCS_BASE_URL}/docs`;
+const DOCS_BASE_URL = `${process.env.DOCS_BASE_URL}/docs`;
 
 interface EntityGroupHeaderProps {
 	title: string;
@@ -29,7 +28,7 @@ function EntityGroupHeader({
 						<>
 							{tooltipTitle}{' '}
 							<a
-								href={`${DOCS_ROOT}${docPath}`}
+								href={`${DOCS_BASE_URL}${docPath}`}
 								target="_blank"
 								rel="noopener"
 								onClick={(e): void => e.stopPropagation()}

frontend/src/container/InfraMonitoringK8sV2/Base/K8sBaseDetails.tsx

@@ -1,10 +1,12 @@
 import { useCallback, useEffect, useMemo } from 'react';
 import { useQuery } from 'react-query';
-import { X } from '@signozhq/icons';
+import { useCopyToClipboard } from 'react-use';
+import { Copy, X } from '@signozhq/icons';
 import { Divider } from '@signozhq/ui/divider';
 import { Button } from '@signozhq/ui/button';
 import { DrawerWrapper, DrawerWrapperProps } from '@signozhq/ui/drawer';
 import { toast } from '@signozhq/ui/sonner';
+import { TooltipSimple } from '@signozhq/ui/tooltip';
 import { Typography } from '@signozhq/ui/typography';
 import logEvent from 'api/common/logEvent';
 import ErrorContent from 'components/ErrorModal/components/ErrorContent';
@@ -18,7 +20,6 @@ import {
 
 import { INFRA_MONITORING_K8S_PARAMS_KEYS } from '../constants';
 import { useInfraMonitoringSelectedItemParams } from '../hooks';
-import CopyButton from 'periscope/components/CopyButton/CopyButton';
 import LoadingContainer from '../LoadingContainer';
 
 import K8sBaseDetailsContent from './K8sBaseDetailsContent';
@@ -94,14 +95,12 @@ export default function K8sBaseDetails<T>({
 				selectedItem,
 				selectedItemParams.clusterName,
 				selectedItemParams.namespaceName,
-				selectedItemParams.containerName,
 			),
 		[
 			queryKeyPrefix,
 			selectedItem,
 			selectedItemParams.clusterName,
 			selectedItemParams.namespaceName,
-			selectedItemParams.containerName,
 			selectedTime,
 			getAutoRefreshQueryKey,
 		],
@@ -171,9 +170,14 @@ export default function K8sBaseDetails<T>({
 		[handleClose],
 	);
 
+	const [, copyToClipboard] = useCopyToClipboard();
+
 	const handleCopyId = useCallback((): void => {
-		toast.success('ID copied to clipboard', { position: 'bottom-left' });
-	}, []);
+		if (selectedItem) {
+			copyToClipboard(selectedItem);
+			toast.success('ID copied to clipboard', { position: 'bottom-left' });
+		}
+	}, [copyToClipboard, selectedItem]);
 
 	const entityName = entity ? getEntityName(entity) : '';
 
@@ -207,13 +211,17 @@ export default function K8sBaseDetails<T>({
 					(isEntityLoading && 'Loading...') ||
 					'-'}
 			</Typography.Text>
-			<CopyButton
-				value={selectedItem ?? ''}
-				ariaLabel="Copy ID"
-				className={styles.copyIdButton}
-				testId="copy-id-button"
-				onCopy={handleCopyId}
-			/>
+			<TooltipSimple title="Copy ID">
+				<Button
+					variant="ghost"
+					size="sm"
+					color="secondary"
+					onClick={handleCopyId}
+					data-testid="copy-id-button"
+				>
+					<Copy size={14} />
+				</Button>
+			</TooltipSimple>
 		</>
 	) as unknown as string;
 

frontend/src/container/InfraMonitoringK8sV2/Base/K8sBaseDetailsContent.tsx

@@ -9,6 +9,7 @@ import {
 import { Button } from '@signozhq/ui/button';
 import { ToggleGroupSimple } from '@signozhq/ui/toggle-group';
 import { TooltipSimple } from '@signozhq/ui/tooltip';
+import { Typography } from '@signozhq/ui/typography';
 import logEvent from 'api/common/logEvent';
 import { combineInitialAndUserExpression } from 'components/QueryBuilderV2/QueryV2/QuerySearch/utils';
 import { InfraMonitoringEvents } from 'constants/events';
@@ -41,7 +42,6 @@ import {
 } from '../hooks';
 
 import { EntityCountsSection } from './components/EntityCountsSection/EntityCountsSection';
-import { EntityMetadataItem } from './components/EntityMetadataItem/EntityMetadataItem';
 import { K8sBaseDetailsContentProps } from './types';
 import { getDrawerDurationMs } from './useDrawerLifecycleStore';
 
@@ -239,18 +239,41 @@ export default function K8sBaseDetailsContent<T>({
 		<>
 			<div className={styles.entityDetailsEntity}>
 				<div className={styles.entityDetailsGrid}>
-					{metadataConfig.map((config) => {
-						const value = config.getValue(entity);
-
-						return (
-							<EntityMetadataItem
+					<div className={styles.labelsRow}>
+						{metadataConfig.map((config) => (
+							<Typography.Text
 								key={config.label}
-								label={config.label}
-								value={String(value)}
-								renderedValue={config.render?.(value, entity)}
-							/>
-						);
-					})}
+								color="muted"
+								size="small"
+								weight="medium"
+								className={styles.entityDetailsMetadataLabel}
+							>
+								{config.label}
+							</Typography.Text>
+						))}
+					</div>
+
+					<div className={styles.valuesRow}>
+						{metadataConfig.map((config) => {
+							const value = config.getValue(entity);
+
+							if (config.render) {
+								return config.render(value, entity);
+							}
+
+							const displayValue = String(value);
+							return (
+								<Typography.Text
+									key={config.label}
+									size="small"
+									weight="medium"
+									className={styles.entityDetailsMetadataValue}
+								>
+									{displayValue}
+								</Typography.Text>
+							);
+						})}
+					</div>
 				</div>
 
 				{countsConfig &&

frontend/src/container/InfraMonitoringK8sV2/Base/K8sBaseList.tsx

@@ -296,7 +296,6 @@ export function K8sBaseList<
 						params.selectedItem,
 						params.clusterName,
 						params.namespaceName,
-						params.containerName,
 					);
 					queryClient.setQueryData(detailQueryKey, { data: record });
 				}
@@ -349,12 +348,6 @@ export function K8sBaseList<
 						params.namespaceName,
 					);
 				}
-				if (params.containerName) {
-					url.searchParams.set(
-						INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_CONTAINER_NAME,
-						params.containerName,
-					);
-				}
 			} else {
 				url.searchParams.set(
 					INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM,

frontend/src/container/InfraMonitoringK8sV2/Base/K8sExpandedRow.module.scss

@@ -19,12 +19,6 @@
 	& [data-hide-expanded='true'] {
 		display: none;
 	}
-
-	// The icon slot is rendered even when the icon inside it is hidden, and the
-	// header's flex gap then indents the title past the values below it.
-	& [data-slot='icon']:has([data-hide-expanded='true']) {
-		display: none;
-	}
 }
 
 .expandedTableFooter {

frontend/src/container/InfraMonitoringK8sV2/Base/K8sExpandedRow.tsx

@@ -214,7 +214,6 @@ export function K8sExpandedRow<
 					params.selectedItem,
 					params.clusterName,
 					params.namespaceName,
-					params.containerName,
 				);
 				queryClient.setQueryData(detailQueryKey, { data: row });
 			}

frontend/src/container/InfraMonitoringK8sV2/Base/components/EntityMetadataItem/EntityMetadataItem.module.scss

@@ -1,44 +0,0 @@
-.metadataItem {
-	display: flex;
-	flex-direction: column;
-	gap: var(--spacing-1);
-	min-width: 0;
-}
-
-.valueRow {
-	display: flex;
-	align-items: center;
-	gap: var(--spacing-1);
-	min-width: 0;
-}
-
-.label {
-	letter-spacing: 0.44px;
-	text-transform: uppercase;
-}
-
-// Single-line ellipsis rather than Typography's `truncate`, which line-clamps:
-// clamping still wraps the text, so a value breaking at a hyphen ends its line
-// early and leaves a gap between the ellipsis and the copy button.
-//
-// This has to be a block: overflow and text-overflow do not apply to inline
-// boxes, and Typography.Text renders an inline span.
-.value {
-	display: block;
-	min-width: 0;
-	white-space: nowrap;
-	overflow: hidden;
-	text-overflow: ellipsis;
-}
-
-.valueText {
-	font-family: var(--periscope-font-family-mono);
-}
-
-// Sized to the icon rather than the default 2rem tap target, so it sits flush
-// against the value instead of floating in its own block of padding.
-.copyButton {
-	--button-padding: 2px;
-	--button-height: auto;
-	--button-width: auto;
-}

frontend/src/container/InfraMonitoringK8sV2/Base/components/EntityMetadataItem/EntityMetadataItem.tsx

@@ -1,63 +0,0 @@
-import { ReactNode, useCallback } from 'react';
-import { toast } from '@signozhq/ui/sonner';
-import { TooltipSimple } from '@signozhq/ui/tooltip';
-import { Typography } from '@signozhq/ui/typography';
-import CopyButton from 'periscope/components/CopyButton/CopyButton';
-
-import styles from './EntityMetadataItem.module.scss';
-
-export interface EntityMetadataItemProps {
-	label: string;
-	value: string;
-	/** An entity-supplied renderer, which opts out of clamping, tooltip and copy. */
-	renderedValue?: ReactNode;
-}
-
-export function EntityMetadataItem({
-	label,
-	value,
-	renderedValue,
-}: EntityMetadataItemProps): JSX.Element {
-	const handleCopy = useCallback((): void => {
-		toast.success(`${label} copied to clipboard`, { position: 'bottom-left' });
-	}, [label]);
-
-	return (
-		<div className={styles.metadataItem}>
-			<Typography.Text
-				color="muted"
-				size="small"
-				weight="medium"
-				className={styles.label}
-			>
-				{label}
-			</Typography.Text>
-
-			{renderedValue ?? (
-				<div className={styles.valueRow}>
-					<TooltipSimple title={value} arrow side="bottom" align="start">
-						<span className={styles.value}>
-							<Typography.Text
-								size="small"
-								weight="medium"
-								className={styles.valueText}
-							>
-								{value}
-							</Typography.Text>
-						</span>
-					</TooltipSimple>
-					{!!value && (
-						<CopyButton
-							value={value}
-							size={10}
-							ariaLabel={`Copy ${label}`}
-							className={styles.copyButton}
-							testId={`copy-metadata-${label.toLowerCase().replace(/\s+/g, '-')}`}
-							onCopy={handleCopy}
-						/>
-					)}
-				</div>
-			)}
-		</div>
-	);
-}

frontend/src/container/InfraMonitoringK8sV2/Base/components/EntityMetadataItem/__tests__/EntityMetadataItem.test.tsx

@@ -1,110 +0,0 @@
-import { render, screen, userEvent, waitFor } from 'tests/test-utils';
-
-import { EntityMetadataItem } from '../EntityMetadataItem';
-
-const mockCopyToClipboard = jest.fn();
-
-jest.mock('react-use', () => ({
-	__esModule: true,
-	useCopyToClipboard: (): [unknown, jest.Mock] => [null, mockCopyToClipboard],
-}));
-
-const mockToastSuccess = jest.fn();
-
-jest.mock('@signozhq/ui/sonner', () => ({
-	...jest.requireActual('@signozhq/ui/sonner'),
-	toast: {
-		success: (...args: unknown[]): unknown => mockToastSuccess(...args),
-	},
-}));
-
-describe('EntityMetadataItem', () => {
-	afterEach(() => {
-		jest.clearAllMocks();
-	});
-
-	it('renders the label and its value', () => {
-		render(<EntityMetadataItem label="Cluster Name" value="prod-cluster" />);
-
-		expect(screen.getByText('Cluster Name')).toBeInTheDocument();
-		expect(screen.getByText('prod-cluster')).toBeInTheDocument();
-	});
-
-	it('copies the full value and confirms which field was copied', async () => {
-		render(
-			<EntityMetadataItem
-				label="Image:Tag"
-				value="ghcr.io/open-telemetry/demo:1.12.0-loadgenerator"
-			/>,
-		);
-
-		await userEvent.click(screen.getByTestId('copy-metadata-image:tag'));
-
-		await waitFor(() => {
-			expect(mockCopyToClipboard).toHaveBeenCalledWith(
-				'ghcr.io/open-telemetry/demo:1.12.0-loadgenerator',
-			);
-		});
-		expect(mockToastSuccess).toHaveBeenCalledWith(
-			'Image:Tag copied to clipboard',
-			expect.anything(),
-		);
-	});
-
-	it('offers no copy control when the value is empty', () => {
-		render(<EntityMetadataItem label="Node" value="" />);
-
-		expect(screen.queryByTestId('copy-metadata-node')).not.toBeInTheDocument();
-	});
-
-	it('exposes the full value on hover', async () => {
-		render(
-			<EntityMetadataItem
-				label="Node"
-				value="gke-mgmt-pl-generator-e2st4-sp-41c1bdc8-zv4t"
-			/>,
-		);
-
-		await userEvent.hover(
-			screen.getByText('gke-mgmt-pl-generator-e2st4-sp-41c1bdc8-zv4t'),
-		);
-
-		await waitFor(() => {
-			expect(
-				screen.getAllByText('gke-mgmt-pl-generator-e2st4-sp-41c1bdc8-zv4t').length,
-			).toBeGreaterThan(1);
-		});
-	});
-
-	it('never presents the value as clickable', () => {
-		render(<EntityMetadataItem label="Node" value="a-very-long-node-name" />);
-
-		const valueEl = screen.getByText('a-very-long-node-name');
-		expect(valueEl).not.toHaveAttribute('data-interactive');
-		expect(valueEl).not.toHaveAttribute('data-truncate');
-	});
-
-	it('triggers the tooltip from the wrapper, never from the text itself', () => {
-		render(<EntityMetadataItem label="Node" value="a-very-long-node-name" />);
-
-		// Radix merges its handlers onto the trigger, and Typography styles
-		// itself interactive off any merged onClick — so the trigger has to stay
-		// off the text.
-		const textEl = screen.getByText('a-very-long-node-name');
-		expect(textEl).not.toHaveAttribute('data-slot', 'tooltip-trigger');
-		expect(textEl.parentElement).toHaveAttribute('data-slot', 'tooltip-trigger');
-	});
-
-	it('leaves an entity-supplied renderer alone', () => {
-		render(
-			<EntityMetadataItem
-				label="Status"
-				value="running"
-				renderedValue={<span data-testid="custom">custom node</span>}
-			/>,
-		);
-
-		expect(screen.getByTestId('custom')).toBeInTheDocument();
-		expect(screen.queryByTestId('copy-metadata-status')).not.toBeInTheDocument();
-	});
-});

frontend/src/container/InfraMonitoringK8sV2/Base/entity.registry.ts

@@ -11,7 +11,6 @@ import { jobEntityConfig } from '../Jobs/entity.config';
 import { daemonSetEntityConfig } from '../DaemonSets/entity.config';
 import { statefulSetEntityConfig } from '../StatefulSets/entity.config';
 import { volumeEntityConfig } from '../Volumes/entity.config';
-import { containerEntityConfig } from '../Containers/entity.config';
 
 type AnyEntityConfig = K8sEntityConfig<
 	K8sEntityData,
@@ -35,7 +34,6 @@ export const entityRegistry: Record<string, AnyEntityConfig> = {
 	[K8sCategories.DAEMONSETS]: registerConfig(daemonSetEntityConfig),
 	[K8sCategories.STATEFULSETS]: registerConfig(statefulSetEntityConfig),
 	[K8sCategories.VOLUMES]: registerConfig(volumeEntityConfig),
-	[K8sCategories.CONTAINERS]: registerConfig(containerEntityConfig),
 };
 
 export function getEntityConfig(category: string): AnyEntityConfig | undefined {

frontend/src/container/InfraMonitoringK8sV2/Containers/__tests__/containers.test.ts

@@ -1,142 +0,0 @@
-import { InframonitoringtypesContainerRecordDTO } from 'api/generated/services/sigNoz.schemas';
-import {
-	k8sContainerGetSelectedItemExpression,
-	k8sContainerInitialEventsExpression,
-	k8sContainerInitialLogTracesExpression,
-} from 'container/InfraMonitoringK8sV2/Containers/constants';
-import { getContainerMetricsQueryPayload } from 'container/InfraMonitoringK8sV2/Containers/metrics';
-import {
-	getK8sContainerItemKey,
-	getK8sContainerRowKey,
-} from 'container/InfraMonitoringK8sV2/Containers/table.config';
-import { getContainerImageWithTag } from 'container/InfraMonitoringK8sV2/Containers/utils';
-
-function makeContainer(
-	overrides: Partial<InframonitoringtypesContainerRecordDTO> = {},
-): InframonitoringtypesContainerRecordDTO {
-	return {
-		containerName: 'nginx',
-		podUID: 'pod-uid-1',
-		meta: {
-			'k8s.container.name': 'nginx',
-			'k8s.pod.uid': 'pod-uid-1',
-			'k8s.pod.name': 'web-0',
-			'k8s.namespace.name': 'production',
-			'k8s.cluster.name': 'prod-cluster',
-			'container.image.name': 'nginx',
-			'container.image.tag': '1.27',
-		},
-		...overrides,
-	} as InframonitoringtypesContainerRecordDTO;
-}
-
-describe('container identity', () => {
-	it('keys a row by the (pod UID, container name) pair', () => {
-		expect(getK8sContainerRowKey(makeContainer())).toBe('pod-uid-1/nginx');
-	});
-
-	it('carries the container name alongside the pod UID into the drawer params', () => {
-		expect(getK8sContainerItemKey(makeContainer())).toStrictEqual({
-			selectedItem: 'pod-uid-1',
-			containerName: 'nginx',
-			clusterName: null,
-			namespaceName: null,
-		});
-	});
-
-	it('falls back to meta when the record fields are empty', () => {
-		const container = makeContainer({ containerName: '', podUID: '' });
-
-		expect(getK8sContainerItemKey(container)).toStrictEqual({
-			selectedItem: 'pod-uid-1',
-			containerName: 'nginx',
-			clusterName: null,
-			namespaceName: null,
-		});
-	});
-
-	it('scopes the details fetch to both halves of the identity', () => {
-		expect(
-			k8sContainerGetSelectedItemExpression({
-				selectedItem: 'pod-uid-1',
-				containerName: 'nginx',
-			}),
-		).toBe("k8s.pod.uid = 'pod-uid-1' AND k8s.container.name = 'nginx'");
-	});
-});
-
-describe('getContainerImageWithTag', () => {
-	it('renders name and tag together', () => {
-		expect(getContainerImageWithTag(makeContainer())).toBe('nginx:1.27');
-	});
-
-	it('drops the tag when the image is not pinned', () => {
-		const container = makeContainer({
-			meta: { 'container.image.name': 'nginx' },
-		});
-
-		expect(getContainerImageWithTag(container)).toBe('nginx');
-	});
-
-	it('renders nothing when the image name is missing', () => {
-		expect(getContainerImageWithTag(makeContainer({ meta: {} }))).toBe('');
-	});
-});
-
-describe('container drawer expressions', () => {
-	it('scopes logs and traces to the container within its pod', () => {
-		expect(k8sContainerInitialLogTracesExpression(makeContainer())).toBe(
-			"k8s.pod.uid = 'pod-uid-1' AND k8s.cluster.name = 'prod-cluster' AND k8s.namespace.name = 'production' AND k8s.container.name = 'nginx'",
-		);
-	});
-
-	it('scopes events to the pod, since k8s emits events per pod', () => {
-		expect(k8sContainerInitialEventsExpression(makeContainer())).toBe(
-			"k8s.object.kind = 'Pod' AND k8s.object.name = 'web-0' AND k8s.cluster.name = 'prod-cluster' AND attribute.k8s.namespace.name = 'production'",
-		);
-	});
-});
-
-describe('getContainerMetricsQueryPayload', () => {
-	const payloads = getContainerMetricsQueryPayload(makeContainer(), 1000, 2000);
-
-	it('returns one payload per documented chart', () => {
-		expect(payloads).toHaveLength(10);
-	});
-
-	it('scopes every query to the selected container', () => {
-		payloads.forEach((payload) => {
-			payload.query.builder.queryData.forEach((query) => {
-				expect(query.filters?.items).toStrictEqual([
-					expect.objectContaining({
-						key: expect.objectContaining({ key: 'k8s.pod.uid' }),
-						op: '=',
-						value: 'pod-uid-1',
-					}),
-					expect.objectContaining({
-						key: expect.objectContaining({ key: 'k8s.container.name' }),
-						op: '=',
-						value: 'nginx',
-					}),
-				]);
-			});
-		});
-	});
-
-	it('derives cache memory from the working set and RSS queries', () => {
-		const memoryByState = payloads[4];
-
-		expect(
-			memoryByState.query.builder.queryData.map((query) => [
-				query.queryName,
-				query.aggregateAttribute?.key,
-			]),
-		).toStrictEqual([
-			['A', 'container.memory.rss'],
-			['B', 'container.memory.working_set'],
-		]);
-		expect(memoryByState.query.builder.queryFormulas).toStrictEqual([
-			expect.objectContaining({ expression: 'B - A', legend: 'Cache Memory' }),
-		]);
-	});
-});

frontend/src/container/InfraMonitoringK8sV2/Containers/constants.ts

@@ -1,170 +0,0 @@
-import { InframonitoringtypesContainerRecordDTO } from 'api/generated/services/sigNoz.schemas';
-import { formatValueForExpression } from 'components/QueryBuilderV2/utils';
-
-import {
-	buildEventsExpression,
-	buildLogsTracesExpression,
-} from '../Base/utils';
-import { K8sDetailsMetadataConfig, K8sDetailsWidgetInfo } from '../Base/types';
-import { INFRA_MONITORING_ATTR_KEYS } from '../constants';
-import { SelectedItemParams } from '../hooks';
-import {
-	CONTAINERS_DOC_PATH,
-	getContainerImageWithTag,
-	getContainerName,
-	getContainerPodUID,
-} from './utils';
-
-/** A container row is identified by the (pod UID, container name) pair. */
-export const k8sContainerGetSelectedItemExpression = (
-	params: SelectedItemParams,
-): string =>
-	[
-		`${INFRA_MONITORING_ATTR_KEYS.K8S_POD_UID} = ${formatValueForExpression(
-			params.selectedItem ?? '',
-		)}`,
-		`${INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME} = ${formatValueForExpression(
-			params.containerName ?? '',
-		)}`,
-	].join(' AND ');
-
-export const k8sContainerGetEntityName = getContainerName;
-
-export const k8sContainerDetailsMetadataConfig: K8sDetailsMetadataConfig<InframonitoringtypesContainerRecordDTO>[] =
-	[
-		{
-			label: 'Pod',
-			getValue: (c): string =>
-				c.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_POD_NAME] || '',
-		},
-		{
-			label: 'NAMESPACE',
-			getValue: (c): string =>
-				c.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_NAMESPACE_NAME] || '',
-		},
-		{
-			label: 'Node',
-			getValue: (c): string =>
-				c.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_NODE_NAME] || '',
-		},
-		{
-			label: 'Cluster Name',
-			getValue: (c): string =>
-				c.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_CLUSTER_NAME] || '',
-		},
-		{
-			label: 'Image:Tag',
-			getValue: getContainerImageWithTag,
-		},
-	];
-
-export const k8sContainerInitialLogTracesExpression = (
-	container: InframonitoringtypesContainerRecordDTO,
-): string => {
-	const base = buildLogsTracesExpression({
-		mainAttributeKey: INFRA_MONITORING_ATTR_KEYS.K8S_POD_UID,
-		mainAttributeValue: getContainerPodUID(container),
-		clusterName: container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_CLUSTER_NAME],
-		namespaceName:
-			container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_NAMESPACE_NAME],
-	});
-
-	const containerName = getContainerName(container);
-	if (!containerName) {
-		return base;
-	}
-
-	const containerClause = `${
-		INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME
-	} = ${formatValueForExpression(containerName)}`;
-
-	return base ? `${base} AND ${containerClause}` : containerClause;
-};
-
-/**
- * Kubernetes emits events against the pod, not the container, so the events tab
- * is scoped to the container's pod.
- */
-export const k8sContainerInitialEventsExpression = (
-	container: InframonitoringtypesContainerRecordDTO,
-): string =>
-	buildEventsExpression({
-		objectKind: 'Pod',
-		objectName: container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_POD_NAME] || '',
-		clusterName: container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_CLUSTER_NAME],
-		namespaceName:
-			container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_NAMESPACE_NAME],
-	});
-
-export const containerWidgetInfo: K8sDetailsWidgetInfo[] = [
-	{
-		title: 'CPU Usage (cores)',
-		yAxisUnit: '',
-		docPath: `${CONTAINERS_DOC_PATH}#cpu-usage-cores-1`,
-		description:
-			'Avg, max and min CPU consumption of the container in cores, showing how bursty it is.',
-	},
-	{
-		title: 'CPU Request, Limit Utilization',
-		yAxisUnit: 'percentunit',
-		docPath: `${CONTAINERS_DOC_PATH}#cpu-request-limit-utilization`,
-		description:
-			'Container CPU usage as a fraction of its own CPU request and limit; limit lines near 100% mean throttling.',
-	},
-	{
-		title: 'Memory Usage (bytes)',
-		yAxisUnit: 'bytes',
-		docPath: `${CONTAINERS_DOC_PATH}#memory-usage-bytes`,
-		description:
-			'Total memory charged to the container, including reclaimable page cache, against the headroom left before its limit.',
-	},
-	{
-		title: 'Memory Request, Limit Utilization',
-		yAxisUnit: 'percentunit',
-		docPath: `${CONTAINERS_DOC_PATH}#memory-request-limit-utilization`,
-		description:
-			'Container memory usage as a fraction of its own memory request and limit; limit lines near 100% risk an OOMKill.',
-	},
-	{
-		title: 'Memory by State',
-		yAxisUnit: 'bytes',
-		docPath: `${CONTAINERS_DOC_PATH}#memory-by-state`,
-		description:
-			'RSS, working set and cache memory of the container, separating heap growth from file cache.',
-	},
-	{
-		title: 'Memory Major Page Faults',
-		yAxisUnit: '',
-		docPath: `${CONTAINERS_DOC_PATH}#memory-major-page-faults`,
-		description:
-			'Major page fault rate of the container; sustained values mean the working set is paging to disk.',
-	},
-	{
-		title: 'File System (bytes)',
-		yAxisUnit: 'bytes',
-		docPath: `${CONTAINERS_DOC_PATH}#file-system-bytes`,
-		description:
-			'Capacity, available and used bytes of the container filesystem.',
-	},
-	{
-		title: 'Container Uptime',
-		yAxisUnit: 's',
-		docPath: `${CONTAINERS_DOC_PATH}#container-uptime`,
-		description:
-			'Time since the container last started; a sawtooth of resets means it is restarting repeatedly.',
-	},
-	{
-		title: 'Node CPU Utilization by Container',
-		yAxisUnit: 'percentunit',
-		docPath: `${CONTAINERS_DOC_PATH}#node-cpu-utilization-by-container`,
-		description:
-			"The container's CPU usage as a fraction of the whole node's capacity, to spot noisy neighbours.",
-	},
-	{
-		title: 'Node Memory Utilization by Container',
-		yAxisUnit: 'percentunit',
-		docPath: `${CONTAINERS_DOC_PATH}#node-memory-utilization-by-container`,
-		description:
-			"The container's memory usage as a fraction of the whole node's capacity.",
-	},
-];

frontend/src/container/InfraMonitoringK8sV2/Containers/entity.config.ts

@@ -1,140 +0,0 @@
-import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
-import { listContainers } from 'api/generated/services/inframonitoring';
-import {
-	InframonitoringtypesContainerRecordDTO,
-	InframonitoringtypesResponseTypeDTO,
-	Querybuildertypesv5OrderDirectionDTO,
-	RenderErrorResponseDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { AxiosError } from 'axios';
-import { InfraMonitoringEvents } from 'constants/events';
-
-import { K8sEntityConfig } from '../Base/entity.config.types';
-import { K8sBaseFilters, K8sDetailsFilters } from '../Base/types';
-import { InfraMonitoringEntity } from '../constants';
-import { SelectedItemParams } from '../hooks';
-import {
-	containerWidgetInfo,
-	k8sContainerDetailsMetadataConfig,
-	k8sContainerGetEntityName,
-	k8sContainerGetSelectedItemExpression,
-	k8sContainerInitialEventsExpression,
-	k8sContainerInitialLogTracesExpression,
-} from './constants';
-import { getContainerMetricsQueryPayload } from './metrics';
-import {
-	getK8sContainerItemKey,
-	getK8sContainerRowKey,
-	k8sContainerColumnsConfig,
-} from './table.config';
-
-async function fetchListData(
-	filters: K8sBaseFilters,
-	signal?: AbortSignal,
-): ReturnType<
-	K8sEntityConfig<
-		InframonitoringtypesContainerRecordDTO,
-		SelectedItemParams
-	>['list']['fetchListData']
-> {
-	try {
-		const response = await listContainers(
-			{
-				filter: { expression: filters.filter.expression },
-				groupBy: filters.groupBy?.map((g) => ({ name: g.name })),
-				offset: filters.offset,
-				limit: filters.limit ?? 10,
-				start: filters.start,
-				end: filters.end,
-				orderBy: filters.orderBy
-					? {
-							key: { name: filters.orderBy.key.name },
-							direction:
-								filters.orderBy.direction === 'asc'
-									? Querybuildertypesv5OrderDirectionDTO.asc
-									: Querybuildertypesv5OrderDirectionDTO.desc,
-						}
-					: undefined,
-			},
-			signal,
-		);
-
-		const data = response.data;
-		return {
-			type:
-				data.type === InframonitoringtypesResponseTypeDTO.grouped_list
-					? ('grouped_list' as const)
-					: ('list' as const),
-			records: data.records,
-			total: data.total,
-			endTimeBeforeRetention: data.endTimeBeforeRetention,
-			warning: data.warning,
-		};
-	} catch (error) {
-		return {
-			type: 'list' as const,
-			records: [] as InframonitoringtypesContainerRecordDTO[],
-			total: 0,
-			error:
-				convertToApiError(error as AxiosError<RenderErrorResponseDTO>) ?? null,
-		};
-	}
-}
-
-async function fetchEntityData(
-	filters: K8sDetailsFilters,
-	signal?: AbortSignal,
-): ReturnType<
-	K8sEntityConfig<InframonitoringtypesContainerRecordDTO>['details']['fetchEntityData']
-> {
-	try {
-		const response = await listContainers(
-			{
-				filter: { expression: filters.filter.expression },
-				start: filters.start,
-				end: filters.end,
-				limit: 1,
-				offset: 0,
-			},
-			signal,
-		);
-
-		return {
-			data: response.data.records.length > 0 ? response.data.records[0] : null,
-		};
-	} catch (error) {
-		return {
-			data: null,
-			error:
-				convertToApiError(error as AxiosError<RenderErrorResponseDTO>) ?? null,
-		};
-	}
-}
-
-export const containerEntityConfig: K8sEntityConfig<
-	InframonitoringtypesContainerRecordDTO,
-	SelectedItemParams
-> = {
-	list: {
-		entity: InfraMonitoringEntity.CONTAINERS,
-		eventCategory: InfraMonitoringEvents.Container,
-		tableColumns: k8sContainerColumnsConfig,
-		fetchListData,
-		getRowKey: getK8sContainerRowKey,
-		getItemKey: getK8sContainerItemKey,
-		detailsQueryKeyPrefix: 'container',
-	},
-	details: {
-		category: InfraMonitoringEntity.CONTAINERS,
-		eventCategory: InfraMonitoringEvents.Container,
-		queryKeyPrefix: 'container',
-		getSelectedItemExpression: k8sContainerGetSelectedItemExpression,
-		fetchEntityData,
-		getEntityName: k8sContainerGetEntityName,
-		getInitialLogTracesExpression: k8sContainerInitialLogTracesExpression,
-		getInitialEventsExpression: k8sContainerInitialEventsExpression,
-		metadataConfig: k8sContainerDetailsMetadataConfig,
-		entityWidgetInfo: containerWidgetInfo,
-		getEntityQueryPayload: getContainerMetricsQueryPayload,
-	},
-};

frontend/src/container/InfraMonitoringK8sV2/Containers/metrics.ts

@@ -1,275 +0,0 @@
-import { InframonitoringtypesContainerRecordDTO } from 'api/generated/services/sigNoz.schemas';
-import { PANEL_TYPES } from 'constants/queryBuilder';
-import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
-import { EQueryType } from 'types/common/dashboard';
-import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
-import { v4 } from 'uuid';
-
-import { INFRA_MONITORING_ATTR_KEYS } from '../constants';
-import { getContainerName, getContainerPodUID } from './utils';
-
-const QUERY_NAMES = ['A', 'B', 'C', 'D', 'E', 'F'];
-const STEP_INTERVAL = 60;
-
-type TimeAggregation = 'avg' | 'max' | 'min' | 'latest';
-type SpaceAggregation = 'sum' | 'avg' | 'max';
-
-interface SeriesSpec {
-	metricKey: string;
-	legend: string;
-	timeAggregation: TimeAggregation;
-	spaceAggregation: SpaceAggregation;
-}
-
-interface FormulaSpec {
-	expression: string;
-	legend: string;
-}
-
-/**
- * Every panel is scoped to a single container by the (k8s.pod.uid,
- * k8s.container.name) pair that identifies its row in the list.
- */
-function buildScopeFilters(
-	container: InframonitoringtypesContainerRecordDTO,
-): TagFilter {
-	return {
-		items: [
-			{
-				id: 'pod-uid',
-				key: {
-					dataType: DataTypes.String,
-					id: `k8s_pod_uid--string--tag--false`,
-					key: INFRA_MONITORING_ATTR_KEYS.K8S_POD_UID,
-					type: 'tag',
-				},
-				op: '=',
-				value: getContainerPodUID(container),
-			},
-			{
-				id: 'container-name',
-				key: {
-					dataType: DataTypes.String,
-					id: `k8s_container_name--string--tag--false`,
-					key: INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME,
-					type: 'tag',
-				},
-				op: '=',
-				value: getContainerName(container),
-			},
-		],
-		op: 'AND',
-	};
-}
-
-function buildQuery(
-	container: InframonitoringtypesContainerRecordDTO,
-	start: number,
-	end: number,
-	series: SeriesSpec[],
-	formulas: FormulaSpec[] = [],
-): GetQueryResultsProps {
-	const filters = buildScopeFilters(container);
-
-	return {
-		selectedTime: 'GLOBAL_TIME',
-		graphType: PANEL_TYPES.TIME_SERIES,
-		query: {
-			builder: {
-				queryData: series.map((spec, index) => ({
-					aggregateAttribute: {
-						dataType: DataTypes.Float64,
-						id: `${spec.metricKey.replace(/\./g, '_')}--float64--Gauge--true`,
-						key: spec.metricKey,
-						type: 'Gauge',
-					},
-					aggregateOperator: spec.timeAggregation,
-					dataSource: DataSource.METRICS,
-					disabled: false,
-					expression: QUERY_NAMES[index],
-					filters,
-					functions: [],
-					groupBy: [],
-					having: [],
-					legend: spec.legend,
-					limit: null,
-					orderBy: [],
-					queryName: QUERY_NAMES[index],
-					reduceTo: ReduceOperators.AVG,
-					spaceAggregation: spec.spaceAggregation,
-					stepInterval: STEP_INTERVAL,
-					timeAggregation: spec.timeAggregation,
-				})),
-				queryFormulas: formulas.map((formula, index) => ({
-					disabled: false,
-					expression: formula.expression,
-					legend: formula.legend,
-					queryName: `F${index + 1}`,
-				})),
-				queryTraceOperator: [],
-			},
-			clickhouse_sql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-			id: v4(),
-			promql: [{ disabled: false, legend: '', name: 'A', query: '' }],
-			queryType: EQueryType.QUERY_BUILDER,
-		},
-		variables: {},
-		formatForWeb: false,
-		start,
-		end,
-	};
-}
-
-/** Absolute usage metrics are summed across series, ratios are averaged. */
-function usageSeries(metricKey: string, legendPrefix = ''): SeriesSpec[] {
-	const prefix = legendPrefix ? `${legendPrefix} - ` : '';
-	return [
-		{
-			metricKey,
-			legend: `${prefix}Avg`,
-			timeAggregation: 'avg',
-			spaceAggregation: 'sum',
-		},
-		{
-			metricKey,
-			legend: `${prefix}Max`,
-			timeAggregation: 'max',
-			spaceAggregation: 'sum',
-		},
-		{
-			metricKey,
-			legend: `${prefix}Min`,
-			timeAggregation: 'min',
-			spaceAggregation: 'sum',
-		},
-	];
-}
-
-function utilizationSeries(
-	metricKey: string,
-	legendPrefix: string,
-): SeriesSpec[] {
-	return (['avg', 'max', 'min'] as TimeAggregation[]).map((timeAggregation) => ({
-		metricKey,
-		legend: `${legendPrefix} - ${
-			timeAggregation.charAt(0).toUpperCase() + timeAggregation.slice(1)
-		}`,
-		timeAggregation,
-		spaceAggregation: 'avg' as const,
-	}));
-}
-
-export const getContainerMetricsQueryPayload = (
-	container: InframonitoringtypesContainerRecordDTO,
-	start: number,
-	end: number,
-): GetQueryResultsProps[] => {
-	const query = (
-		series: SeriesSpec[],
-		formulas?: FormulaSpec[],
-	): GetQueryResultsProps => buildQuery(container, start, end, series, formulas);
-
-	return [
-		query(usageSeries(INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE)),
-		query([
-			...utilizationSeries(
-				INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_CPU_REQUEST_UTILIZATION,
-				'Request util %',
-			),
-			...utilizationSeries(
-				INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_CPU_LIMIT_UTILIZATION,
-				'Limit util %',
-			),
-		]),
-		query([
-			...usageSeries(INFRA_MONITORING_ATTR_KEYS.CONTAINER_MEMORY_USAGE, 'Usage'),
-			{
-				metricKey: INFRA_MONITORING_ATTR_KEYS.CONTAINER_MEMORY_AVAILABLE,
-				legend: 'Available',
-				timeAggregation: 'avg',
-				spaceAggregation: 'sum',
-			},
-		]),
-		query([
-			...utilizationSeries(
-				INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_MEMORY_REQUEST_UTILIZATION,
-				'Request util %',
-			),
-			...utilizationSeries(
-				INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_MEMORY_LIMIT_UTILIZATION,
-				'Limit util %',
-			),
-		]),
-		query(
-			[
-				{
-					metricKey: INFRA_MONITORING_ATTR_KEYS.CONTAINER_MEMORY_RSS,
-					legend: 'RSS Memory',
-					timeAggregation: 'avg',
-					spaceAggregation: 'sum',
-				},
-				{
-					metricKey: INFRA_MONITORING_ATTR_KEYS.CONTAINER_MEMORY_WORKING_SET,
-					legend: 'Working Set Memory',
-					timeAggregation: 'avg',
-					spaceAggregation: 'sum',
-				},
-			],
-			[{ expression: 'B - A', legend: 'Cache Memory' }],
-		),
-		query([
-			{
-				metricKey: INFRA_MONITORING_ATTR_KEYS.CONTAINER_MEMORY_MAJOR_PAGE_FAULTS,
-				legend: 'Major Page Faults',
-				timeAggregation: 'avg',
-				spaceAggregation: 'sum',
-			},
-		]),
-		query([
-			{
-				metricKey: INFRA_MONITORING_ATTR_KEYS.CONTAINER_FILESYSTEM_CAPACITY,
-				legend: 'Capacity',
-				timeAggregation: 'avg',
-				spaceAggregation: 'sum',
-			},
-			{
-				metricKey: INFRA_MONITORING_ATTR_KEYS.CONTAINER_FILESYSTEM_AVAILABLE,
-				legend: 'Available',
-				timeAggregation: 'avg',
-				spaceAggregation: 'sum',
-			},
-			{
-				metricKey: INFRA_MONITORING_ATTR_KEYS.CONTAINER_FILESYSTEM_USAGE,
-				legend: 'Usage',
-				timeAggregation: 'avg',
-				spaceAggregation: 'sum',
-			},
-		]),
-		query([
-			{
-				metricKey: INFRA_MONITORING_ATTR_KEYS.CONTAINER_UPTIME,
-				legend: 'Uptime',
-				timeAggregation: 'latest',
-				spaceAggregation: 'sum',
-			},
-		]),
-		query([
-			{
-				metricKey: INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_CPU_NODE_UTILIZATION,
-				legend: 'Node CPU Utilization',
-				timeAggregation: 'avg',
-				spaceAggregation: 'avg',
-			},
-		]),
-		query([
-			{
-				metricKey: INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_MEMORY_NODE_UTILIZATION,
-				legend: 'Node Memory Utilization',
-				timeAggregation: 'avg',
-				spaceAggregation: 'avg',
-			},
-		]),
-	];
-};

frontend/src/container/InfraMonitoringK8sV2/Containers/table.config.tsx

@@ -1,470 +0,0 @@
-import { Container } from '@signozhq/icons';
-import { Badge } from '@signozhq/ui/badge';
-import {
-	InframonitoringtypesContainerReadyDTO,
-	InframonitoringtypesContainerRecordDTO,
-	InframonitoringtypesContainerStatusDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import TanStackTable, { TableColumnDef } from 'components/TanStackTableView';
-import { ExpandButtonWrapper } from 'container/InfraMonitoringK8sV2/components';
-
-import ColumnHeader from '../Base/ColumnHeader';
-import EntityGroupHeader from '../Base/EntityGroupHeader';
-import K8sGroupCell from '../Base/K8sGroupCell';
-import { formatBytes } from '../commonUtils';
-import {
-	EntityProgressBar,
-	EntityProgressThresholds,
-	GroupedStatusCounts,
-	TextNoData,
-	ValidateColumnValueWrapper,
-} from '../components';
-import {
-	INFRA_MONITORING_ATTR_KEYS,
-	InfraMonitoringEntity,
-} from '../constants';
-import { SelectedItemParams } from '../hooks';
-import {
-	CONTAINER_READY_COLORS,
-	CONTAINER_READY_LABELS,
-	CONTAINER_STATUS_COLORS,
-	CONTAINER_STATUS_LABELS,
-	CONTAINERS_DOC_PATH,
-	getContainerImageWithTag,
-	getContainerReadyItems,
-	getContainerStatusItems,
-} from './utils';
-
-export function getK8sContainerRowKey(
-	container: InframonitoringtypesContainerRecordDTO,
-): string {
-	return (
-		[container.podUID, container.containerName].filter(Boolean).join('/') ||
-		container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME] ||
-		''
-	);
-}
-
-export function getK8sContainerItemKey(
-	container: InframonitoringtypesContainerRecordDTO,
-): SelectedItemParams {
-	return {
-		selectedItem:
-			container.podUID ||
-			container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_POD_UID] ||
-			null,
-		containerName:
-			container.containerName ||
-			container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME] ||
-			null,
-		clusterName: null,
-		namespaceName: null,
-	};
-}
-
-export type ContainerTableColumnConfig =
-	TableColumnDef<InframonitoringtypesContainerRecordDTO>;
-
-/**
- * The grouped table and its nested rows are separate tables, so a column and the
- * one that replaces it while grouped share a width to keep the two aligned.
- */
-const NAME_COLUMN_WIDTH = 220;
-const STATUS_COLUMN_WIDTH = 250;
-
-export const k8sContainerColumnsConfig: ContainerTableColumnConfig[] = [
-	{
-		id: 'containerGroup',
-		header: (): React.ReactNode => <EntityGroupHeader title="Container Group" />,
-		accessorFn: (row): string => row.containerName || '',
-		width: { min: NAME_COLUMN_WIDTH },
-		enableSort: false,
-		enableRemove: false,
-		enableMove: false,
-		pin: 'left',
-		visibilityBehavior: 'hidden-on-collapse',
-		cell: ({ isExpanded, toggleExpanded, row }): JSX.Element | null => (
-			<ExpandButtonWrapper isExpanded={isExpanded} toggleExpanded={toggleExpanded}>
-				<K8sGroupCell row={row} />
-			</ExpandButtonWrapper>
-		),
-	},
-	{
-		id: INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME,
-		header: (): React.ReactNode => (
-			<EntityGroupHeader
-				title="Container Name"
-				icon={<Container data-hide-expanded="true" size={14} />}
-				docPath={`${CONTAINERS_DOC_PATH}#container-name`}
-			/>
-		),
-		accessorFn: (row): string =>
-			row.containerName ||
-			row.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME] ||
-			'',
-		width: { min: NAME_COLUMN_WIDTH },
-		enableSort: true,
-		enableRemove: false,
-		enableMove: false,
-		pin: 'left',
-		visibilityBehavior: 'hidden-on-expand',
-		cell: ({ value }): React.ReactNode => (
-			<TanStackTable.Text>{value as string}</TanStackTable.Text>
-		),
-	},
-	{
-		id: 'podName',
-		header: (): React.ReactNode => (
-			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#pod-name`}>
-				Pod Name
-			</ColumnHeader>
-		),
-		accessorFn: (row): string =>
-			row.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_POD_NAME] || '',
-		width: { min: 260 },
-		enableSort: false,
-		cell: ({ value }): React.ReactNode => {
-			const podName = value as string;
-			if (!podName) {
-				return <TextNoData type="tanstack" />;
-			}
-			return <TanStackTable.Text>{podName}</TanStackTable.Text>;
-		},
-	},
-	{
-		id: 'namespace',
-		header: (): React.ReactNode => (
-			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#additional-columns`}>
-				Namespace
-			</ColumnHeader>
-		),
-		accessorFn: (row): string =>
-			row.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_NAMESPACE_NAME] || '',
-		width: { min: 160 },
-		enableSort: false,
-		cell: ({ value }): React.ReactNode => (
-			<TanStackTable.Text>{value as string}</TanStackTable.Text>
-		),
-	},
-	{
-		id: 'image',
-		header: (): React.ReactNode => (
-			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#imagetag`}>
-				Image:Tag
-			</ColumnHeader>
-		),
-		accessorFn: (row): string => getContainerImageWithTag(row),
-		width: { min: 240 },
-		enableSort: false,
-		cell: ({ value }): React.ReactNode => {
-			const image = value as string;
-			if (!image) {
-				return <TextNoData type="tanstack" />;
-			}
-			return <TanStackTable.Text>{image}</TanStackTable.Text>;
-		},
-	},
-	{
-		id: 'containerStatus',
-		header: (): React.ReactNode => (
-			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#status`}>Status</ColumnHeader>
-		),
-		accessorFn: (row): string => row.status,
-		width: { min: STATUS_COLUMN_WIDTH },
-		enableSort: false,
-		visibilityBehavior: 'hidden-on-expand',
-		cell: ({ row }): React.ReactNode => {
-			if (
-				!row.status ||
-				row.status === InframonitoringtypesContainerStatusDTO.no_data
-			) {
-				return <TextNoData type="tanstack" />;
-			}
-
-			return (
-				<Badge color={CONTAINER_STATUS_COLORS[row.status]} variant="outline">
-					{CONTAINER_STATUS_LABELS[row.status]}
-				</Badge>
-			);
-		},
-	},
-	{
-		id: 'containerCountsByStatus',
-		header: (): React.ReactNode => (
-			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#status`}>Status</ColumnHeader>
-		),
-		accessorFn: (
-			row,
-		): InframonitoringtypesContainerRecordDTO['containerCountsByStatus'] =>
-			row.containerCountsByStatus,
-		width: { min: STATUS_COLUMN_WIDTH },
-		enableSort: false,
-		visibilityBehavior: 'hidden-on-collapse',
-		cell: ({ row, rowId }): React.ReactNode => {
-			if (!row.containerCountsByStatus) {
-				return <TextNoData type="tanstack" />;
-			}
-			return (
-				<GroupedStatusCounts
-					items={getContainerStatusItems(row.containerCountsByStatus)}
-					rowId={rowId}
-				/>
-			);
-		},
-	},
-	{
-		id: 'containerReady',
-		header: (): React.ReactNode => (
-			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#ready`}>Ready</ColumnHeader>
-		),
-		accessorFn: (row): string => row.ready,
-		width: { min: 130 },
-		enableSort: false,
-		visibilityBehavior: 'hidden-on-expand',
-		cell: ({ row }): React.ReactNode => {
-			if (
-				!row.ready ||
-				row.ready === InframonitoringtypesContainerReadyDTO.no_data
-			) {
-				return <TextNoData type="tanstack" />;
-			}
-
-			return (
-				<Badge color={CONTAINER_READY_COLORS[row.ready]} variant="outline">
-					{CONTAINER_READY_LABELS[row.ready]}
-				</Badge>
-			);
-		},
-	},
-	{
-		id: 'containerCountsByReady',
-		header: (): React.ReactNode => (
-			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#ready`}>Ready</ColumnHeader>
-		),
-		accessorFn: (
-			row,
-		): InframonitoringtypesContainerRecordDTO['containerCountsByReady'] =>
-			row.containerCountsByReady,
-		width: { min: 130 },
-		enableSort: false,
-		visibilityBehavior: 'hidden-on-collapse',
-		cell: ({ row, rowId }): React.ReactNode => {
-			if (!row.containerCountsByReady) {
-				return <TextNoData type="tanstack" />;
-			}
-			return (
-				<GroupedStatusCounts
-					items={getContainerReadyItems(row.containerCountsByReady)}
-					rowId={rowId}
-				/>
-			);
-		},
-	},
-	{
-		id: 'containerRestarts',
-		header: (): React.ReactNode => (
-			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#restarts`}>
-				Restarts
-			</ColumnHeader>
-		),
-		accessorFn: (row): number => row.restarts,
-		width: { min: 130 },
-		enableSort: false,
-		cell: ({ value, rowId }): React.ReactNode => (
-			<ValidateColumnValueWrapper
-				rowId={rowId}
-				value={value as number}
-				entity={InfraMonitoringEntity.CONTAINERS}
-				attribute="Restarts"
-			>
-				<TanStackTable.Text>{value as number}</TanStackTable.Text>
-			</ValidateColumnValueWrapper>
-		),
-	},
-	{
-		id: 'cpu_request',
-		header: (): React.ReactNode => (
-			<ColumnHeader
-				docPath={`${CONTAINERS_DOC_PATH}#cpu-req-usage-`}
-				tooltip={<EntityProgressThresholds type="cpu-request" />}
-			>
-				CPU Request Usage (%)
-			</ColumnHeader>
-		),
-		accessorFn: (row): number => row.cpuRequestUtilization,
-		width: { min: 210 },
-		enableSort: true,
-		cell: ({ value, rowId }): React.ReactNode => (
-			<ValidateColumnValueWrapper
-				rowId={rowId}
-				value={value as number}
-				entity={InfraMonitoringEntity.CONTAINERS}
-				attribute="CPU Request"
-			>
-				<EntityProgressBar value={value as number} type="cpu-request" />
-			</ValidateColumnValueWrapper>
-		),
-	},
-	{
-		id: 'cpu_limit',
-		header: (): React.ReactNode => (
-			<ColumnHeader
-				docPath={`${CONTAINERS_DOC_PATH}#cpu-limit-usage-`}
-				tooltip={<EntityProgressThresholds type="cpu-limit" />}
-			>
-				CPU Limit Usage (%)
-			</ColumnHeader>
-		),
-		accessorFn: (row): number => row.cpuLimitUtilization,
-		width: { min: 220 },
-		enableSort: true,
-		cell: ({ value, rowId }): React.ReactNode => (
-			<ValidateColumnValueWrapper
-				rowId={rowId}
-				value={value as number}
-				entity={InfraMonitoringEntity.CONTAINERS}
-				attribute="CPU Limit"
-			>
-				<EntityProgressBar value={value as number} type="cpu-limit" />
-			</ValidateColumnValueWrapper>
-		),
-	},
-	{
-		id: 'cpu',
-		header: (): React.ReactNode => (
-			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#cpu-usage-cores`}>
-				CPU Usage (cores)
-			</ColumnHeader>
-		),
-		accessorFn: (row): number => row.cpu,
-		width: { min: 160 },
-		enableSort: true,
-		cell: ({ value, rowId }): React.ReactNode => (
-			<ValidateColumnValueWrapper
-				rowId={rowId}
-				value={Number(value)}
-				entity={InfraMonitoringEntity.CONTAINERS}
-				attribute="CPU metric"
-			>
-				<TanStackTable.Text>{Number(value).toFixed(2)}</TanStackTable.Text>
-			</ValidateColumnValueWrapper>
-		),
-	},
-	{
-		id: 'memory_request',
-		header: (): React.ReactNode => (
-			<ColumnHeader
-				docPath={`${CONTAINERS_DOC_PATH}#mem-req-usage-`}
-				tooltip={<EntityProgressThresholds type="memory-request" />}
-			>
-				Memory Request Usage (%)
-			</ColumnHeader>
-		),
-		accessorFn: (row): number => row.memoryRequestUtilization,
-		width: { min: 210 },
-		enableSort: true,
-		cell: ({ value, rowId }): React.ReactNode => (
-			<ValidateColumnValueWrapper
-				rowId={rowId}
-				value={value as number}
-				entity={InfraMonitoringEntity.CONTAINERS}
-				attribute="Memory Request"
-			>
-				<EntityProgressBar value={value as number} type="memory-request" />
-			</ValidateColumnValueWrapper>
-		),
-	},
-	{
-		id: 'memory_limit',
-		header: (): React.ReactNode => (
-			<ColumnHeader
-				docPath={`${CONTAINERS_DOC_PATH}#mem-limit-usage-`}
-				tooltip={<EntityProgressThresholds type="memory-limit" />}
-			>
-				Memory Limit Usage (%)
-			</ColumnHeader>
-		),
-		accessorFn: (row): number => row.memoryLimitUtilization,
-		width: { min: 220 },
-		enableSort: true,
-		cell: ({ value, rowId }): React.ReactNode => (
-			<ValidateColumnValueWrapper
-				rowId={rowId}
-				value={value as number}
-				entity={InfraMonitoringEntity.CONTAINERS}
-				attribute="Memory Limit"
-			>
-				<EntityProgressBar value={value as number} type="memory-limit" />
-			</ValidateColumnValueWrapper>
-		),
-	},
-	{
-		id: 'memory',
-		header: (): React.ReactNode => (
-			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#mem-usage-wss`}>
-				Memory Usage (WSS)
-			</ColumnHeader>
-		),
-		accessorFn: (row): number => row.memory,
-		width: { min: 210, default: '100%' },
-		enableSort: true,
-		cell: ({ value, rowId }): React.ReactNode => (
-			<ValidateColumnValueWrapper
-				rowId={rowId}
-				value={value as number}
-				entity={InfraMonitoringEntity.CONTAINERS}
-				attribute="memory metric"
-			>
-				<TanStackTable.Text>{formatBytes(value as number)}</TanStackTable.Text>
-			</ValidateColumnValueWrapper>
-		),
-	},
-	{
-		id: 'node',
-		header: (): React.ReactNode => (
-			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#additional-columns`}>
-				Node
-			</ColumnHeader>
-		),
-		accessorFn: (row): string =>
-			row.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_NODE_NAME] || '',
-		width: { default: 100 },
-		enableSort: false,
-		defaultVisibility: false,
-		cell: ({ value }): React.ReactNode => (
-			<TanStackTable.Text>{value as string}</TanStackTable.Text>
-		),
-	},
-	{
-		id: 'cluster',
-		header: (): React.ReactNode => (
-			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#additional-columns`}>
-				Cluster
-			</ColumnHeader>
-		),
-		accessorFn: (row): string =>
-			row.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_CLUSTER_NAME] || '',
-		width: { default: 100 },
-		enableSort: false,
-		defaultVisibility: false,
-		cell: ({ value }): React.ReactNode => (
-			<TanStackTable.Text>{value as string}</TanStackTable.Text>
-		),
-	},
-	{
-		id: 'deployment',
-		header: (): React.ReactNode => (
-			<ColumnHeader docPath={`${CONTAINERS_DOC_PATH}#additional-columns`}>
-				Deployment
-			</ColumnHeader>
-		),
-		accessorFn: (row): string =>
-			row.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_DEPLOYMENT_NAME] || '',
-		width: { default: 100 },
-		enableSort: false,
-		defaultVisibility: false,
-		cell: ({ value }): React.ReactNode => (
-			<TanStackTable.Text>{value as string}</TanStackTable.Text>
-		),
-	},
-];

frontend/src/container/InfraMonitoringK8sV2/Containers/utils.ts

@@ -1,169 +0,0 @@
-import { Color } from '@signozhq/design-tokens';
-import { BadgeColor } from '@signozhq/ui/badge';
-import {
-	InframonitoringtypesContainerCountsByReadyDTO,
-	InframonitoringtypesContainerCountsByStatusDTO,
-	InframonitoringtypesContainerReadyDTO,
-	InframonitoringtypesContainerRecordDTO,
-	InframonitoringtypesContainerStatusDTO,
-} from 'api/generated/services/sigNoz.schemas';
-
-import { StatusCountItem } from '../components/GroupedStatusCounts';
-import { INFRA_MONITORING_ATTR_KEYS } from '../constants';
-
-export const CONTAINERS_DOC_PATH =
-	'/infrastructure-monitoring/kubernetes/containers';
-
-/** Renders as `name:tag`; the tag is dropped when the image is not pinned. */
-export function getContainerImageWithTag(
-	container: InframonitoringtypesContainerRecordDTO,
-): string {
-	const name = container.meta?.[INFRA_MONITORING_ATTR_KEYS.CONTAINER_IMAGE_NAME];
-	const tag = container.meta?.[INFRA_MONITORING_ATTR_KEYS.CONTAINER_IMAGE_TAG];
-
-	if (!name) {
-		return '';
-	}
-
-	return tag ? `${name}:${tag}` : name;
-}
-
-export function getContainerName(
-	container: InframonitoringtypesContainerRecordDTO,
-): string {
-	return (
-		container.containerName ||
-		container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME] ||
-		''
-	);
-}
-
-export function getContainerPodUID(
-	container: InframonitoringtypesContainerRecordDTO,
-): string {
-	return (
-		container.podUID ||
-		container.meta?.[INFRA_MONITORING_ATTR_KEYS.K8S_POD_UID] ||
-		''
-	);
-}
-
-export const CONTAINER_STATUS_COLORS: Record<
-	InframonitoringtypesContainerStatusDTO,
-	BadgeColor
-> = {
-	[InframonitoringtypesContainerStatusDTO.running]: 'forest',
-	[InframonitoringtypesContainerStatusDTO.completed]: 'robin',
-	[InframonitoringtypesContainerStatusDTO.waiting]: 'amber',
-	[InframonitoringtypesContainerStatusDTO.containercreating]: 'amber',
-	[InframonitoringtypesContainerStatusDTO.terminated]: 'sienna',
-	[InframonitoringtypesContainerStatusDTO.unknown]: 'vanilla',
-	[InframonitoringtypesContainerStatusDTO.no_data]: 'vanilla',
-	[InframonitoringtypesContainerStatusDTO.crashloopbackoff]: 'cherry',
-	[InframonitoringtypesContainerStatusDTO.imagepullbackoff]: 'cherry',
-	[InframonitoringtypesContainerStatusDTO.errimagepull]: 'cherry',
-	[InframonitoringtypesContainerStatusDTO.createcontainerconfigerror]: 'cherry',
-	[InframonitoringtypesContainerStatusDTO.oomkilled]: 'cherry',
-	[InframonitoringtypesContainerStatusDTO.error]: 'cherry',
-	[InframonitoringtypesContainerStatusDTO.containercannotrun]: 'cherry',
-};
-
-/** kubectl prints these as single CamelCase words, so the enum value alone is not a usable label. */
-export const CONTAINER_STATUS_LABELS: Record<
-	InframonitoringtypesContainerStatusDTO,
-	string
-> = {
-	[InframonitoringtypesContainerStatusDTO.running]: 'Running',
-	[InframonitoringtypesContainerStatusDTO.completed]: 'Completed',
-	[InframonitoringtypesContainerStatusDTO.waiting]: 'Waiting',
-	[InframonitoringtypesContainerStatusDTO.containercreating]:
-		'ContainerCreating',
-	[InframonitoringtypesContainerStatusDTO.terminated]: 'Terminated',
-	[InframonitoringtypesContainerStatusDTO.unknown]: 'Unknown',
-	[InframonitoringtypesContainerStatusDTO.no_data]: 'No data',
-	[InframonitoringtypesContainerStatusDTO.crashloopbackoff]: 'CrashLoopBackOff',
-	[InframonitoringtypesContainerStatusDTO.imagepullbackoff]: 'ImagePullBackOff',
-	[InframonitoringtypesContainerStatusDTO.errimagepull]: 'ErrImagePull',
-	[InframonitoringtypesContainerStatusDTO.createcontainerconfigerror]:
-		'CreateContainerConfigError',
-	[InframonitoringtypesContainerStatusDTO.oomkilled]: 'OOMKilled',
-	[InframonitoringtypesContainerStatusDTO.error]: 'Error',
-	[InframonitoringtypesContainerStatusDTO.containercannotrun]:
-		'ContainerCannotRun',
-};
-
-const CONTAINER_ERROR_STATUS_LABELS: Partial<
-	Record<keyof InframonitoringtypesContainerCountsByStatusDTO, string>
-> = {
-	crashLoopBackOff: 'CrashLoopBackOff',
-	imagePullBackOff: 'ImagePullBackOff',
-	errImagePull: 'ErrImagePull',
-	createContainerConfigError: 'CreateContainerConfigError',
-	oomKilled: 'OOMKilled',
-	error: 'Error',
-	containerCannotRun: 'ContainerCannotRun',
-};
-
-export function getContainerStatusItems(
-	counts: InframonitoringtypesContainerCountsByStatusDTO,
-): StatusCountItem[] {
-	const errorKeys = Object.keys(CONTAINER_ERROR_STATUS_LABELS) as Array<
-		keyof typeof CONTAINER_ERROR_STATUS_LABELS
-	>;
-
-	return [
-		{ value: counts.running, label: 'Running', color: Color.BG_FOREST_500 },
-		{ value: counts.completed, label: 'Completed', color: Color.BG_ROBIN_500 },
-		{
-			value: counts.waiting + counts.containerCreating,
-			label: 'Waiting',
-			color: Color.BG_AMBER_500,
-			breakdown: [
-				{ label: 'Waiting', value: counts.waiting },
-				{ label: 'ContainerCreating', value: counts.containerCreating },
-			],
-		},
-		{
-			value: counts.terminated,
-			label: 'Terminated',
-			color: Color.BG_SIENNA_500,
-		},
-		{ value: counts.unknown, label: 'Unknown', color: Color.BG_SLATE_400 },
-		{
-			value: errorKeys.reduce((sum, key) => sum + counts[key], 0),
-			label: 'Error Status',
-			color: Color.BG_CHERRY_500,
-			breakdown: errorKeys.map((key) => ({
-				label: CONTAINER_ERROR_STATUS_LABELS[key] as string,
-				value: counts[key],
-			})),
-		},
-	];
-}
-
-export const CONTAINER_READY_COLORS: Record<
-	InframonitoringtypesContainerReadyDTO,
-	BadgeColor
-> = {
-	[InframonitoringtypesContainerReadyDTO.ready]: 'forest',
-	[InframonitoringtypesContainerReadyDTO.not_ready]: 'cherry',
-	[InframonitoringtypesContainerReadyDTO.no_data]: 'vanilla',
-};
-
-export const CONTAINER_READY_LABELS: Record<
-	InframonitoringtypesContainerReadyDTO,
-	string
-> = {
-	[InframonitoringtypesContainerReadyDTO.ready]: 'Ready',
-	[InframonitoringtypesContainerReadyDTO.not_ready]: 'Not Ready',
-	[InframonitoringtypesContainerReadyDTO.no_data]: 'No data',
-};
-
-export function getContainerReadyItems(
-	counts: InframonitoringtypesContainerCountsByReadyDTO,
-): StatusCountItem[] {
-	return [
-		{ value: counts.ready, label: 'Ready', color: Color.BG_FOREST_500 },
-		{ value: counts.notReady, label: 'Not Ready', color: Color.BG_CHERRY_500 },
-	];
-}

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityMetrics/ChartHeader.tsx

@@ -3,9 +3,8 @@ import { Compass, Info } from '@signozhq/icons';
 import { TooltipSimple } from '@signozhq/ui/tooltip';
 
 import styles from './ChartHeader.module.scss';
-import { DOCS_BASE_URL } from 'constants/app';
 
-const DOCS_ROOT = `${DOCS_BASE_URL}/docs`;
+const DOCS_BASE_URL = `${process.env.DOCS_BASE_URL}/docs`;
 
 interface ChartHeaderProps {
 	title: string;
@@ -34,7 +33,7 @@ function ChartHeader({
 						<>
 							{tooltipTitle}{' '}
 							<a
-								href={`${DOCS_ROOT}${docPath}`}
+								href={`${DOCS_BASE_URL}${docPath}`}
 								target="_blank"
 								rel="noopener"
 								onClick={(e): void => e.stopPropagation()}

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/entityDetails.module.scss

@@ -37,15 +37,7 @@
 .title {
 	font-family: var(--periscope-font-family-mono);
 
-	--typography-margin: 0px var(--spacing-1) 0px 0px;
-}
-
-// Sized to the icon rather than the default tap target, so it sits beside the
-// entity name instead of a gap away from it.
-.copyIdButton {
-	--button-padding: 2px;
-	--button-height: auto;
-	--button-width: auto;
+	--typography-margin: 0px var(--spacing-4) 0px 0px;
 }
 
 .entityDetailsEntity {
@@ -53,12 +45,30 @@
 	flex-direction: column;
 }
 
-// Tracks size to the entity's field count instead of a fixed four, so entities
-// with more fields stay on one row rather than spilling a near-empty second one.
 .entityDetailsGrid {
+	display: flex;
+	flex-direction: column;
+}
+
+.labelsRow,
+.valuesRow {
 	display: grid;
-	grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
-	gap: var(--spacing-4) var(--spacing-6);
+	grid-template-columns: 1.5fr 1.5fr 1.5fr 1.5fr;
+	gap: 30px;
+	align-items: center;
+}
+
+.labelsRow {
+	margin-bottom: var(--spacing-4);
+}
+
+.entityDetailsMetadataLabel {
+	letter-spacing: 0.44px;
+	text-transform: uppercase;
+}
+
+.entityDetailsMetadataValue {
+	font-family: var(--periscope-font-family-mono);
 }
 
 .viewsTabsContainer {

frontend/src/container/InfraMonitoringK8sV2/InfraMonitoringK8s.tsx

@@ -16,7 +16,6 @@ import {
 	ArrowUpDown,
 	ArrowUpToLine,
 	Bolt,
-	Box,
 	Boxes,
 	Computer,
 	Container,
@@ -32,7 +31,6 @@ import { DataSource } from 'types/common/queryBuilder';
 import { K8sDynamicList } from './Base/K8sDynamicList';
 import {
 	GetClustersQuickFiltersConfig,
-	GetContainersQuickFiltersConfig,
 	GetDaemonsetsQuickFiltersConfig,
 	GetDeploymentsQuickFiltersConfig,
 	GetJobsQuickFiltersConfig,
@@ -154,12 +152,6 @@ export default function InfraMonitoringK8s(): JSX.Element {
 
 	const categories = useMemo(
 		() => [
-			{
-				key: K8sCategories.CONTAINERS,
-				label: 'Containers',
-				icon: <Box size={14} />,
-				config: GetContainersQuickFiltersConfig(),
-			},
 			{
 				key: K8sCategories.PODS,
 				label: 'Pods',

frontend/src/container/InfraMonitoringK8sV2/constants.ts

@@ -61,26 +61,10 @@ export const INFRA_MONITORING_ATTR_KEYS = {
 	K8S_CONTAINER_CPU_LIMIT: 'k8s.container.cpu_limit',
 	K8S_CONTAINER_MEMORY_REQUEST: 'k8s.container.memory_request',
 	K8S_CONTAINER_MEMORY_LIMIT: 'k8s.container.memory_limit',
-	K8S_CONTAINER_CPU_REQUEST_UTILIZATION: 'k8s.container.cpu_request_utilization',
-	K8S_CONTAINER_CPU_LIMIT_UTILIZATION: 'k8s.container.cpu_limit_utilization',
-	K8S_CONTAINER_MEMORY_REQUEST_UTILIZATION:
-		'k8s.container.memory_request_utilization',
-	K8S_CONTAINER_MEMORY_LIMIT_UTILIZATION:
-		'k8s.container.memory_limit_utilization',
-	K8S_CONTAINER_CPU_NODE_UTILIZATION: 'k8s.container.cpu.node.utilization',
-	K8S_CONTAINER_MEMORY_NODE_UTILIZATION: 'k8s.container.memory.node.utilization',
 	CONTAINER_CPU_USAGE: 'container.cpu.usage',
 	CONTAINER_MEMORY_USAGE: 'container.memory.usage',
-	CONTAINER_MEMORY_AVAILABLE: 'container.memory.available',
 	CONTAINER_MEMORY_WORKING_SET: 'container.memory.working_set',
 	CONTAINER_MEMORY_RSS: 'container.memory.rss',
-	CONTAINER_MEMORY_MAJOR_PAGE_FAULTS: 'container.memory.major_page_faults',
-	CONTAINER_FILESYSTEM_AVAILABLE: 'container.filesystem.available',
-	CONTAINER_FILESYSTEM_CAPACITY: 'container.filesystem.capacity',
-	CONTAINER_FILESYSTEM_USAGE: 'container.filesystem.usage',
-	CONTAINER_UPTIME: 'container.uptime',
-	CONTAINER_IMAGE_NAME: 'container.image.name',
-	CONTAINER_IMAGE_TAG: 'container.image.tag',
 
 	// Deployment
 	K8S_DEPLOYMENT_NAME: 'k8s.deployment.name',
@@ -181,9 +165,6 @@ export const K8sCategories = {
 	VOLUMES: 'volumes',
 };
 
-/** The section the Kubernetes view opens on when a link names none. */
-export const DEFAULT_K8S_CATEGORY = K8sCategories.CONTAINERS;
-
 const dotMap = {
 	[InfraMonitoringEntity.HOSTS]:
 		INFRA_MONITORING_ATTR_KEYS.SYSTEM_CPU_LOAD_AVERAGE_15M,
@@ -200,7 +181,7 @@ const dotMap = {
 	[InfraMonitoringEntity.DAEMONSETS]:
 		INFRA_MONITORING_ATTR_KEYS.K8S_POD_CPU_USAGE,
 	[InfraMonitoringEntity.CONTAINERS]:
-		INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
+		INFRA_MONITORING_ATTR_KEYS.K8S_POD_CPU_USAGE,
 	[InfraMonitoringEntity.JOBS]:
 		INFRA_MONITORING_ATTR_KEYS.K8S_JOB_DESIRED_SUCCESSFUL_PODS,
 	[InfraMonitoringEntity.VOLUMES]:
@@ -340,161 +321,6 @@ export function GetPodsQuickFiltersConfig(): IQuickFiltersConfig[] {
 	];
 }
 
-export function GetContainersQuickFiltersConfig(): IQuickFiltersConfig[] {
-	return [
-		{
-			type: FiltersType.CHECKBOX,
-			title: 'Container',
-			attributeKey: {
-				key: INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME,
-				dataType: DataTypes.String,
-				type: 'resource',
-				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_CONTAINER_NAME}--string--resource--false`,
-			},
-			aggregateOperator: 'noop',
-			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
-			dataSource: DataSource.METRICS,
-			defaultOpen: true,
-		},
-		{
-			type: FiltersType.CHECKBOX,
-			title: 'Pod',
-			attributeKey: {
-				key: INFRA_MONITORING_ATTR_KEYS.K8S_POD_NAME,
-				dataType: DataTypes.String,
-				type: 'resource',
-				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_POD_NAME}--string--resource--false`,
-			},
-			aggregateOperator: 'noop',
-			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
-			dataSource: DataSource.METRICS,
-			defaultOpen: true,
-		},
-		{
-			type: FiltersType.CHECKBOX,
-			title: 'Namespace',
-			attributeKey: {
-				key: INFRA_MONITORING_ATTR_KEYS.K8S_NAMESPACE_NAME,
-				dataType: DataTypes.String,
-				type: 'resource',
-				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_NAMESPACE_NAME}--string--resource--false`,
-			},
-			aggregateOperator: 'noop',
-			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
-			dataSource: DataSource.METRICS,
-			defaultOpen: false,
-		},
-		{
-			type: FiltersType.CHECKBOX,
-			title: 'Node',
-			attributeKey: {
-				key: INFRA_MONITORING_ATTR_KEYS.K8S_NODE_NAME,
-				dataType: DataTypes.String,
-				type: 'resource',
-				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_NODE_NAME}--string--resource--false`,
-			},
-			aggregateOperator: 'noop',
-			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
-			dataSource: DataSource.METRICS,
-			defaultOpen: false,
-		},
-		{
-			type: FiltersType.CHECKBOX,
-			title: 'Cluster',
-			attributeKey: {
-				key: INFRA_MONITORING_ATTR_KEYS.K8S_CLUSTER_NAME,
-				dataType: DataTypes.String,
-				type: 'resource',
-				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_CLUSTER_NAME}--string--resource--false`,
-			},
-			aggregateOperator: 'noop',
-			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
-			dataSource: DataSource.METRICS,
-			defaultOpen: false,
-		},
-		{
-			type: FiltersType.CHECKBOX,
-			title: 'Image',
-			attributeKey: {
-				key: INFRA_MONITORING_ATTR_KEYS.CONTAINER_IMAGE_NAME,
-				dataType: DataTypes.String,
-				type: 'resource',
-				id: `${INFRA_MONITORING_ATTR_KEYS.CONTAINER_IMAGE_NAME}--string--resource--false`,
-			},
-			aggregateOperator: 'noop',
-			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
-			dataSource: DataSource.METRICS,
-			defaultOpen: false,
-		},
-		{
-			type: FiltersType.CHECKBOX,
-			title: 'Deployment',
-			attributeKey: {
-				key: INFRA_MONITORING_ATTR_KEYS.K8S_DEPLOYMENT_NAME,
-				dataType: DataTypes.String,
-				type: 'resource',
-				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_DEPLOYMENT_NAME}--string--resource--false`,
-			},
-			aggregateOperator: 'noop',
-			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
-			dataSource: DataSource.METRICS,
-			defaultOpen: false,
-		},
-		{
-			type: FiltersType.CHECKBOX,
-			title: 'Statefulset',
-			attributeKey: {
-				key: INFRA_MONITORING_ATTR_KEYS.K8S_STATEFULSET_NAME,
-				dataType: DataTypes.String,
-				type: 'resource',
-				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_STATEFULSET_NAME}--string--resource--false`,
-			},
-			aggregateOperator: 'noop',
-			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
-			dataSource: DataSource.METRICS,
-			defaultOpen: false,
-		},
-		{
-			type: FiltersType.CHECKBOX,
-			title: 'DaemonSet',
-			attributeKey: {
-				key: INFRA_MONITORING_ATTR_KEYS.K8S_DAEMONSET_NAME,
-				dataType: DataTypes.String,
-				type: 'resource',
-				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_DAEMONSET_NAME}--string--resource--false`,
-			},
-			aggregateOperator: 'noop',
-			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
-			dataSource: DataSource.METRICS,
-			defaultOpen: false,
-		},
-		{
-			type: FiltersType.CHECKBOX,
-			title: 'Job',
-			attributeKey: {
-				key: INFRA_MONITORING_ATTR_KEYS.K8S_JOB_NAME,
-				dataType: DataTypes.String,
-				type: 'resource',
-				id: `${INFRA_MONITORING_ATTR_KEYS.K8S_JOB_NAME}--string--resource--false`,
-			},
-			aggregateOperator: 'noop',
-			aggregateAttribute: INFRA_MONITORING_ATTR_KEYS.CONTAINER_CPU_USAGE,
-			dataSource: DataSource.METRICS,
-			defaultOpen: false,
-		},
-		{
-			type: FiltersType.CHECKBOX,
-			title: 'Environment',
-			attributeKey: {
-				key: INFRA_MONITORING_ATTR_KEYS.DEPLOYMENT_ENVIRONMENT,
-				dataType: DataTypes.String,
-				type: 'resource',
-			},
-			defaultOpen: true,
-		},
-	];
-}
-
 export function GetNodesQuickFiltersConfig(): IQuickFiltersConfig[] {
 	return [
 		{
@@ -941,7 +767,6 @@ export const INFRA_MONITORING_K8S_PARAMS_KEYS = {
 	SELECTED_ITEM: 'selectedItem',
 	SELECTED_ITEM_CLUSTER_NAME: 'selectedItemClusterName',
 	SELECTED_ITEM_NAMESPACE_NAME: 'selectedItemNamespaceName',
-	SELECTED_ITEM_CONTAINER_NAME: 'selectedItemContainerName',
 	DETAIL_RELATIVE_TIME: 'detailRelativeTime',
 	DETAIL_START_TIME: 'detailStartTime',
 	DETAIL_END_TIME: 'detailEndTime',
@@ -958,7 +783,7 @@ export const METRIC_NAMESPACE_BY_ENTITY: Record<InfraMonitoringEntity, string> =
 		[InfraMonitoringEntity.DEPLOYMENTS]: 'k8s.',
 		[InfraMonitoringEntity.STATEFULSETS]: 'k8s.',
 		[InfraMonitoringEntity.DAEMONSETS]: 'k8s.',
-		[InfraMonitoringEntity.CONTAINERS]: 'k8s.container.',
+		[InfraMonitoringEntity.CONTAINERS]: 'k8s.pod.',
 		[InfraMonitoringEntity.JOBS]: 'k8s.',
 		[InfraMonitoringEntity.VOLUMES]: 'k8s.volume.',
 	};

frontend/src/container/InfraMonitoringK8sV2/hooks.ts

@@ -16,8 +16,8 @@ import {
 import { parseAsJsonNoValidate } from 'utils/nuqsParsers';
 
 import {
-	DEFAULT_K8S_CATEGORY,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
+	K8sCategories,
 	VIEWS,
 } from './constants';
 import { orderBySchema, OrderBySchemaType } from './schemas';
@@ -130,23 +130,19 @@ export const useInfraMonitoringCategory = (): UseQueryStateReturn<
 > =>
 	useQueryState(
 		INFRA_MONITORING_K8S_PARAMS_KEYS.CATEGORY,
-		parseAsString
-			.withDefault(DEFAULT_K8S_CATEGORY)
-			.withOptions({ ...defaultNuqsOptions, clearOnDefault: false }),
+		parseAsString.withDefault(K8sCategories.PODS).withOptions(defaultNuqsOptions),
 	);
 
 export interface SelectedItemParams {
 	selectedItem: string | null;
 	clusterName?: string | null;
 	namespaceName?: string | null;
-	containerName?: string | null;
 }
 
 const selectedItemParamsParsers = {
 	[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM]: parseAsString,
 	[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_CLUSTER_NAME]: parseAsString,
 	[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_NAMESPACE_NAME]: parseAsString,
-	[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_CONTAINER_NAME]: parseAsString,
 };
 
 export type UseSelectedItemParamsReturn = [
@@ -171,9 +167,6 @@ export const useInfraMonitoringSelectedItemParams =
 				namespaceName:
 					rawParams[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_NAMESPACE_NAME] ??
 					null,
-				containerName:
-					rawParams[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_CONTAINER_NAME] ??
-					null,
 			}),
 			[rawParams],
 		);
@@ -185,7 +178,6 @@ export const useInfraMonitoringSelectedItemParams =
 						[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM]: null,
 						[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_CLUSTER_NAME]: null,
 						[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_NAMESPACE_NAME]: null,
-						[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_CONTAINER_NAME]: null,
 					});
 					return;
 				}
@@ -197,8 +189,6 @@ export const useInfraMonitoringSelectedItemParams =
 						newParams.clusterName ?? null,
 					[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_NAMESPACE_NAME]:
 						newParams.namespaceName ?? null,
-					[INFRA_MONITORING_K8S_PARAMS_KEYS.SELECTED_ITEM_CONTAINER_NAME]:
-						newParams.containerName ?? null,
 				});
 			},
 			[setRawParams],

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

@@ -38,20 +38,19 @@ import {
 	TEST_ENDPOINT,
 } from '../../__tests__/fixtures';
 
-const SAMPLE_SPAN = JSON.parse(SAMPLE_SPAN_JSON) as {
-	attributes: Record<string, unknown>;
-	resource: Record<string, unknown>;
-};
-
-const MAPPED_ATTRIBUTE_KEY = 'gen_ai.content.prompt';
-
-// Deriving from the sample keeps exactly one key added, so the single `populated` badge assertion below stays exact.
 const RESULT_SPAN = {
 	attributes: {
-		...SAMPLE_SPAN.attributes,
-		[MAPPED_ATTRIBUTE_KEY]: SAMPLE_SPAN.attributes['input.value'],
+		'my_company.llm.input': 'What is quantum computing?',
+		'llm.input_messages': 'What is quantum computing?',
+		'gen_ai.request.model': 'gpt-4',
+		'gen_ai.usage.total_tokens': 1250,
+		'gen_ai.content.completion': 'Quantum computing leverages...',
+		'gen_ai.content.prompt': 'What is quantum computing?',
+	},
+	resource: {
+		'service.name': 'llm-gateway',
+		'deployment.environment': 'production',
 	},
-	resource: SAMPLE_SPAN.resource,
 };
 
 const EDITED_SPAN_JSON = `{
@@ -98,7 +97,7 @@ describe('TestTab — sample-span flow', () => {
 		).resolves.toBeInTheDocument();
 		expect(screen.getByTestId('test-result-0')).toBeInTheDocument();
 		expect(screen.getByTestId('test-result-0-attributes')).toHaveTextContent(
-			MAPPED_ATTRIBUTE_KEY,
+			'gen_ai.content.prompt',
 		);
 		expect(screen.getByText('populated')).toBeInTheDocument();
 		expect(screen.queryByTestId('test-error')).not.toBeInTheDocument();

frontend/src/container/LLMObservability/AttributeMapping/TestTab/spanInputStorage.ts

@@ -7,14 +7,11 @@ import { parseSpanInput } from './testPayload';
 
 export const SAMPLE_SPAN_JSON = `{
   "attributes": {
-    "llm.model_name": "gpt-4o",
-    "llm.provider": "openai",
-    "llm.token_count.prompt": 1024,
-    "llm.token_count.completion": 226,
-    "llm.token_count.prompt_details.cache_read": 512,
-    "input.value": "What is quantum computing?",
-    "output.value": "Quantum computing leverages superposition and entanglement...",
-    "session.id": "chat-8f2e41"
+    "my_company.llm.input": "What is quantum computing?",
+    "llm.input_messages": "What is quantum computing?",
+    "gen_ai.request.model": "gpt-4",
+    "gen_ai.usage.total_tokens": 1250,
+    "gen_ai.content.completion": "Quantum computing leverages..."
   },
   "resource": {
     "service.name": "llm-gateway",

frontend/src/container/Licenses/ApplyLicenseForm.tsx

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

frontend/src/container/LogDetailedView/BodyTitleRenderer.tsx

@@ -16,6 +16,7 @@ import {
 } from 'constants/antlrQueryConstants';
 import { FeatureKeys } from 'constants/features';
 import { useActiveLog } from 'hooks/logs/useActiveLog';
+import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { ICurrentQueryData } from 'hooks/useHandleExplorerTabChange';
 import { useNotifications } from 'hooks/useNotifications';
@@ -48,6 +49,7 @@ function BodyTitleRenderer({
 	const { featureFlags } = useAppContext();
 	const [, setCopy] = useCopyToClipboard();
 	const { notifications } = useNotifications();
+	const { viewName } = useGetSavedViewParams();
 
 	const cleanedNodeKey = removeObjectFromString(nodeKey);
 	const isBodyJsonQueryEnabled =
@@ -121,6 +123,8 @@ function BodyTitleRenderer({
 		);
 
 		const queryData: ICurrentQueryData = {
+			name: viewName,
+			id: updatedQuery.id,
 			query: updatedQuery,
 		};
 
@@ -133,6 +137,7 @@ function BodyTitleRenderer({
 		stagedQuery,
 		updateQueriesData,
 		value,
+		viewName,
 	]);
 
 	const onClickHandler = (key: string): void => {

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

@@ -12,6 +12,7 @@ import ROUTES from 'constants/routes';
 import { ChangeViewFunctionType } from 'container/ExplorerOptions/types';
 import { RESTRICTED_SELECTED_FIELDS } from 'container/LogsFilters/config';
 import { MetricsType } from 'container/MetricsApplication/constant';
+import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { ICurrentQueryData } from 'hooks/useHandleExplorerTabChange';
 import {
@@ -139,6 +140,7 @@ export default function TableViewActions(
 
 	const { pathname } = useLocation();
 	const { stagedQuery, updateQueriesData } = useQueryBuilder();
+	const { viewName } = useGetSavedViewParams();
 	const { dataType, logType: fieldType } = getFieldAttributes(record.field);
 
 	// there is no option for where clause in old logs explorer and live logs page or infra monitoring
@@ -199,6 +201,8 @@ export default function TableViewActions(
 		);
 
 		const queryData: ICurrentQueryData = {
+			name: viewName,
+			id: updatedQuery.id,
 			query: updatedQuery,
 		};
 
@@ -210,6 +214,7 @@ export default function TableViewActions(
 		fieldType,
 		dataType,
 		handleChangeSelectedView,
+		viewName,
 	]);
 
 	const handleReplaceFilter = useCallback((): void => {
@@ -259,6 +264,8 @@ export default function TableViewActions(
 		);
 
 		const queryData: ICurrentQueryData = {
+			name: viewName,
+			id: updatedQuery.id,
 			query: updatedQuery,
 		};
 
@@ -271,6 +278,7 @@ export default function TableViewActions(
 		dataType,
 		fieldData,
 		handleChangeSelectedView,
+		viewName,
 	]);
 
 	// Memoize textToCopy computation

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

@@ -272,6 +272,8 @@ describe('TableViewActions', () => {
 		expect(defaultProps.handleChangeSelectedView).toHaveBeenCalledWith(
 			ExplorerViews.TIMESERIES,
 			expect.objectContaining({
+				name: '',
+				id: 'test-query-id',
 				query: expect.objectContaining({
 					builder: expect.objectContaining({
 						queryData: expect.arrayContaining([

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

@@ -5,6 +5,7 @@ import { convertFiltersToExpression } from 'components/QueryBuilderV2/utils';
 import { FeatureKeys } from 'constants/features';
 import ROUTES from 'constants/routes';
 import { ChangeViewFunctionType } from 'container/ExplorerOptions/types';
+import { useGetSavedViewParams } from 'hooks/saveViews/useGetSavedViewParams';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { ICurrentQueryData } from 'hooks/useHandleExplorerTabChange';
 import { ExplorerViews } from 'pages/LogsExplorer/utils';
@@ -56,6 +57,7 @@ export function useLogAttributeActions({
 	const { pathname } = useLocation();
 	const { stagedQuery, updateQueriesData } = useQueryBuilder();
 	const { featureFlags } = useAppContext();
+	const { viewName } = useGetSavedViewParams();
 
 	const isBodyJsonQueryEnabled =
 		featureFlags?.find((flag) => flag.name === FeatureKeys.USE_JSON_BODY)
@@ -108,6 +110,8 @@ export function useLogAttributeActions({
 			);
 
 			const queryData: ICurrentQueryData = {
+				name: viewName,
+				id: updatedQuery.id,
 				query: updatedQuery,
 			};
 			handleChangeSelectedView?.(ExplorerViews.LIST, queryData);
@@ -116,6 +120,7 @@ export function useLogAttributeActions({
 			stagedQuery,
 			isBodyJsonQueryEnabled,
 			updateQueriesData,
+			viewName,
 			handleChangeSelectedView,
 			onApplyLogFilter,
 		],
@@ -142,6 +147,8 @@ export function useLogAttributeActions({
 			);
 
 			const queryData: ICurrentQueryData = {
+				name: viewName,
+				id: updatedQuery.id,
 				query: updatedQuery,
 			};
 			handleChangeSelectedView?.(ExplorerViews.TIMESERIES, queryData);
@@ -150,6 +157,7 @@ export function useLogAttributeActions({
 			stagedQuery,
 			isBodyJsonQueryEnabled,
 			updateQueriesData,
+			viewName,
 			handleChangeSelectedView,
 		],
 	);
@@ -175,6 +183,8 @@ export function useLogAttributeActions({
 			);
 
 			const queryData: ICurrentQueryData = {
+				name: viewName,
+				id: updatedQuery.id,
 				query: updatedQuery,
 			};
 			handleChangeSelectedView?.(ExplorerViews.LIST, queryData);
@@ -183,6 +193,7 @@ export function useLogAttributeActions({
 			stagedQuery,
 			isBodyJsonQueryEnabled,
 			updateQueriesData,
+			viewName,
 			handleChangeSelectedView,
 		],
 	);

frontend/src/container/MetricsExplorer/MetricDetails/AllAttributes.tsx

@@ -78,6 +78,8 @@ function AllAttributes({
 				PANEL_TYPES.TIME_SERIES,
 				{
 					query: compositeQuery,
+					name: metricName,
+					id: metricName,
 				},
 				ROUTES.METRICS_EXPLORER_EXPLORER,
 				true,
@@ -107,6 +109,8 @@ function AllAttributes({
 				PANEL_TYPES.TIME_SERIES,
 				{
 					query: compositeQuery,
+					name: metricName,
+					id: metricName,
 				},
 				ROUTES.METRICS_EXPLORER_EXPLORER,
 				true,

frontend/src/container/MetricsExplorer/MetricDetails/MetricDetails.tsx

@@ -92,6 +92,8 @@ function MetricDetails({
 				PANEL_TYPES.TIME_SERIES,
 				{
 					query: compositeQuery,
+					name: metricName,
+					id: metricName,
 				},
 				ROUTES.METRICS_EXPLORER_EXPLORER,
 				true,

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

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

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

@@ -1,11 +1,5 @@
 import userEvent from '@testing-library/user-event';
 import MySettingsContainer from 'container/MySettings';
-import useActiveLicenseKey from 'hooks/useActiveLicenseKey/useActiveLicenseKey';
-import {
-	setupAuthzAdmin,
-	setupAuthzDenyAll,
-} from 'lib/authz/utils/authz-test-utils';
-import { server } from 'mocks-server/server';
 import { logEventMock } from '__tests__/logEventMock';
 import {
 	act,
@@ -18,11 +12,6 @@ import {
 import APIError from 'types/api/error';
 import { toast } from '@signozhq/ui/sonner';
 
-jest.mock('hooks/useActiveLicenseKey/useActiveLicenseKey');
-const mockUseActiveLicenseKey = useActiveLicenseKey as jest.MockedFunction<
-	typeof useActiveLicenseKey
->;
-
 const toggleThemeFunction = jest.fn();
 const copyToClipboardFn = jest.fn();
 const editUserFn = jest.fn();
@@ -98,10 +87,6 @@ describe('MySettings Flows', () => {
 		jest.clearAllMocks();
 		editUserFn.mockResolvedValue({});
 		updateMyPasswordFn.mockResolvedValue({});
-		mockUseActiveLicenseKey.mockReturnValue({
-			licenseKey: 'test-key',
-			isLoading: false,
-		});
 		render(<MySettingsContainer />);
 	});
 
@@ -376,27 +361,17 @@ describe('MySettings Flows', () => {
 	});
 
 	describe('License section', () => {
-		beforeEach(() => {
-			server.use(setupAuthzAdmin());
-		});
-
-		afterEach(() => {
-			server.resetHandlers();
-		});
-
-		it('Should render license section content when license key exists', async () => {
+		it('Should render license section content when license key exists', () => {
 			expect(screen.getByText('License')).toBeInTheDocument();
-			await expect(screen.findByText('License key')).resolves.toBeInTheDocument();
+			expect(screen.getByText('License key')).toBeInTheDocument();
 			expect(screen.getByText('Your SigNoz license key.')).toBeInTheDocument();
 		});
 
-		it('Should not render license section when there is no active license', () => {
-			mockUseActiveLicenseKey.mockReturnValue({
-				licenseKey: undefined,
-				isLoading: false,
-			});
+		it('Should not render license section when license key is missing', () => {
 			const { container } = render(<MySettingsContainer />, undefined, {
-				appContextOverrides: { activeLicense: null },
+				appContextOverrides: {
+					activeLicense: null,
+				},
 			});
 
 			const scoped = within(container);
@@ -407,53 +382,41 @@ describe('MySettings Flows', () => {
 			).not.toBeInTheDocument();
 		});
 
-		it('Should show permission denied instead of the license key when read is denied', async () => {
-			server.use(setupAuthzDenyAll());
-			const { container } = render(<MySettingsContainer />);
+		it('Should mask license key in the UI', () => {
+			const { container } = render(<MySettingsContainer />, undefined, {
+				appContextOverrides: {
+					activeLicense: {
+						key: 'abcd',
+					} as any,
+				},
+			});
 
-			const scoped = within(container);
-			await expect(
-				scoped.findByText(/not authorized/i),
-			).resolves.toBeInTheDocument();
-			expect(scoped.getByText('License')).toBeInTheDocument();
-			expect(scoped.queryByText('License key')).not.toBeInTheDocument();
+			expect(within(container).getByText('ab·······cd')).toBeInTheDocument();
 		});
 
-		it('Should mask license key in the UI', async () => {
-			mockUseActiveLicenseKey.mockReturnValue({
-				licenseKey: 'abcd',
-				isLoading: false,
+		it('Should not mask license key if it is too short', () => {
+			const { container } = render(<MySettingsContainer />, undefined, {
+				appContextOverrides: {
+					activeLicense: {
+						key: 'abc',
+					} as any,
+				},
 			});
-			const { container } = render(<MySettingsContainer />);
 
-			await expect(
-				within(container).findByText('ab·······cd'),
-			).resolves.toBeInTheDocument();
-		});
-
-		it('Should not mask license key if it is too short', async () => {
-			mockUseActiveLicenseKey.mockReturnValue({
-				licenseKey: 'abc',
-				isLoading: false,
-			});
-			const { container } = render(<MySettingsContainer />);
-
-			await expect(
-				within(container).findByText('abc'),
-			).resolves.toBeInTheDocument();
+			expect(within(container).getByText('abc')).toBeInTheDocument();
 		});
 
 		it('Should copy license key and show success toast', async () => {
 			const user = userEvent.setup();
-			mockUseActiveLicenseKey.mockReturnValue({
-				licenseKey: 'test-license-key-12345',
-				isLoading: false,
+			const { container } = render(<MySettingsContainer />, undefined, {
+				appContextOverrides: {
+					activeLicense: {
+						key: 'test-license-key-12345',
+					} as any,
+				},
 			});
-			const { container } = render(<MySettingsContainer />);
 
-			await user.click(
-				await within(container).findByTestId('license-key-copy-btn'),
-			);
+			await user.click(within(container).getByTestId('license-key-copy-btn'));
 
 			await waitFor(() => {
 				expect(copyToClipboardFn).toHaveBeenCalledWith('test-license-key-12345');

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

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

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

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

frontend/src/hooks/useActiveLicense/useActiveLicense.tsx

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

frontend/src/hooks/useActiveLicense/utils.ts

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

frontend/src/hooks/useActiveLicenseKey/useActiveLicenseKey.tsx

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

frontend/src/hooks/useActiveLicenseV3/useActiveLicenseV3.tsx

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

frontend/src/hooks/useHandleExplorerTabChange.ts

@@ -10,8 +10,8 @@ import { useGetSavedViewParams } from './saveViews/useGetSavedViewParams';
 import { useQueryBuilder } from './queryBuilder/useQueryBuilder';
 
 export interface ICurrentQueryData {
-	viewName?: string;
-	viewKey?: string;
+	name: string;
+	id: string;
 	query: Query;
 }
 
@@ -57,8 +57,6 @@ export const useHandleExplorerTabChange = (): {
 		[currentQuery, updateAllQueriesOperators, updateQueriesData],
 	);
 
-	//TODO: this util is used not just to change explorer tab but also
-	// for changing just the query or saved view. consider renaming this.
 	const handleExplorerTabChange = useCallback(
 		(
 			type: string,
@@ -79,8 +77,8 @@ export const useHandleExplorerTabChange = (): {
 					query,
 					{
 						[QueryParams.panelTypes]: newPanelType,
-						[QueryParams.viewName]: currentQueryData?.viewName || viewName,
-						[QueryParams.viewKey]: currentQueryData?.viewKey || viewKey,
+						[QueryParams.viewName]: currentQueryData?.name || viewName,
+						[QueryParams.viewKey]: currentQueryData?.id || viewKey,
 					},
 					redirectToUrl,
 					undefined,
@@ -91,8 +89,8 @@ export const useHandleExplorerTabChange = (): {
 					query,
 					{
 						[QueryParams.panelTypes]: newPanelType,
-						[QueryParams.viewName]: currentQueryData?.viewName || viewName,
-						[QueryParams.viewKey]: currentQueryData?.viewKey || viewKey,
+						[QueryParams.viewName]: currentQueryData?.name || viewName,
+						[QueryParams.viewKey]: currentQueryData?.id || viewKey,
 					},
 					undefined,
 					undefined,

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

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

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

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

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

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

frontend/src/pages/ChannelsEdit/index.tsx

@@ -11,8 +11,6 @@ import ROUTES from 'constants/routes';
 import {
 	ChannelType,
 	GoogleChatChannel,
-	JiraChannel,
-	JsmOpsChannel,
 	MsTeamsChannel,
 	PagerChannel,
 	SlackChannel,
@@ -62,25 +60,17 @@ function ChannelsEdit(): JSX.Element {
 
 	const prepChannelConfig = (): {
 		type: string;
-		channel: Partial<
-			SlackChannel &
-				WebhookChannel &
-				PagerChannel &
-				MsTeamsChannel &
-				GoogleChatChannel &
-				JiraChannel &
-				JsmOpsChannel
-		>;
+		channel: SlackChannel &
+			WebhookChannel &
+			PagerChannel &
+			MsTeamsChannel &
+			GoogleChatChannel;
 	} => {
-		let channel: Partial<
-			SlackChannel &
-				WebhookChannel &
-				PagerChannel &
-				MsTeamsChannel &
-				GoogleChatChannel &
-				JiraChannel &
-				JsmOpsChannel
-		> = {
+		let channel: SlackChannel &
+			WebhookChannel &
+			PagerChannel &
+			MsTeamsChannel &
+			GoogleChatChannel = {
 			name: '',
 		};
 
@@ -111,19 +101,6 @@ function ChannelsEdit(): JSX.Element {
 			};
 		}
 
-		if (value && 'jira_configs' in value) {
-			const [jiraConfig] = value.jira_configs;
-			channel = jiraConfig;
-			if (jiraConfig.http_config?.basic_auth) {
-				channel.username = jiraConfig.http_config.basic_auth.username;
-				channel.password = jiraConfig.http_config.basic_auth.password;
-			}
-			return {
-				type: ChannelType.Jira,
-				channel,
-			};
-		}
-
 		if (value && 'pagerduty_configs' in value) {
 			const pagerConfig = value.pagerduty_configs[0];
 			channel = pagerConfig;
@@ -135,22 +112,6 @@ function ChannelsEdit(): JSX.Element {
 			};
 		}
 
-		if (value && 'jsmops_configs' in value) {
-			const [jsmopsConfig] = value.jsmops_configs;
-			channel = jsmopsConfig;
-			// backend stores tags as a comma-separated string; the form uses chips
-			channel.tags = jsmopsConfig.tags
-				? String(jsmopsConfig.tags)
-						.split(',')
-						.map((tag: string) => tag.trim())
-						.filter(Boolean)
-				: [];
-			return {
-				type: ChannelType.JsmOps,
-				channel,
-			};
-		}
-
 		if (value && 'opsgenie_configs' in value) {
 			const opsgenieConfig = value.opsgenie_configs[0];
 			channel = opsgenieConfig;

frontend/src/pages/InfrastructureMonitoring/constants.tsx

@@ -2,10 +2,6 @@ import { TabRoutes } from 'components/RouteTab/types';
 import ROUTES from 'constants/routes';
 import InfraMonitoringHostsV2 from 'container/InfraMonitoringHostsV2';
 import InfraMonitoringK8sV2 from 'container/InfraMonitoringK8sV2';
-import {
-	DEFAULT_K8S_CATEGORY,
-	INFRA_MONITORING_K8S_PARAMS_KEYS,
-} from 'container/InfraMonitoringK8sV2/constants';
 import { Inbox } from '@signozhq/icons';
 
 function HostsContainer(): JSX.Element {
@@ -34,6 +30,6 @@ export const Kubernetes: TabRoutes = {
 			<Inbox size={16} /> Kubernetes
 		</div>
 	),
-	route: `${ROUTES.INFRASTRUCTURE_MONITORING_KUBERNETES}?${INFRA_MONITORING_K8S_PARAMS_KEYS.CATEGORY}=${DEFAULT_K8S_CATEGORY}`,
+	route: ROUTES.INFRASTRUCTURE_MONITORING_KUBERNETES,
 	key: ROUTES.INFRASTRUCTURE_MONITORING_KUBERNETES,
 };

frontend/src/pages/SaveView/index.tsx

@@ -209,8 +209,8 @@ function SaveView(): JSX.Element {
 				currentPanelType,
 				{
 					query,
-					viewName: name,
-					viewKey: id,
+					name,
+					id,
 				},
 				SOURCEPAGE_VS_ROUTES[sourcepage],
 			);

frontend/src/providers/App/App.tsx

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

frontend/src/tests/test-utils.tsx

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

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

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

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

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

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

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