Merge branch 'develop' into release/v0.58.x

* feat: support for window based pagination in new trace v4

* fix: update pagination logic

* fix: update comment

* fix: substract correct length

* fix: revert changes

* fix: add tests for querier

* fix: rename matcher

* fix: handle offset inmemory for list queries in traces

* fix: correct var name

* fix: add max pagination limit for traces

.github/workflows/docs.yml

@@ -0,0 +1,83 @@
+name: "Update PR labels and Block PR until related docs are shipped for the feature"
+
+on:
+  pull_request:
+    branches:
+      - develop
+    types: [opened, edited, labeled, unlabeled]
+
+permissions:
+  pull-requests: write
+  contents: read
+
+jobs:
+  docs_label_check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check PR Title and Manage Labels
+        uses: actions/github-script@v6
+        with:
+          script: |
+            const prTitle = context.payload.pull_request.title;
+            const prNumber = context.payload.pull_request.number;
+            const owner = context.repo.owner;
+            const repo = context.repo.repo;
+
+            // Fetch the current PR details to get labels
+            const pr = await github.rest.pulls.get({
+              owner,
+              repo,
+              pull_number: prNumber
+            });
+
+            const labels = pr.data.labels.map(label => label.name);
+
+            if (prTitle.startsWith('feat:')) {
+              const hasDocsRequired = labels.includes('docs required');
+              const hasDocsShipped = labels.includes('docs shipped');
+              const hasDocsNotRequired = labels.includes('docs not required');
+
+              // If "docs not required" is present, skip the checks
+              if (hasDocsNotRequired && !hasDocsRequired) {
+                console.log("Skipping checks due to 'docs not required' label.");
+                return; // Exit the script early
+              }
+              
+              // If "docs shipped" is present, remove "docs required" if it exists
+              if (hasDocsShipped && hasDocsRequired) {
+                await github.rest.issues.removeLabel({
+                  owner,
+                  repo,
+                  issue_number: prNumber,
+                  name: 'docs required'
+                });
+                console.log("Removed 'docs required' label.");
+              }
+
+              // Add "docs required" label if neither "docs shipped" nor "docs required" are present
+              if (!hasDocsRequired && !hasDocsShipped) {
+                await github.rest.issues.addLabels({
+                  owner,
+                  repo,
+                  issue_number: prNumber,
+                  labels: ['docs required']
+                });
+                console.log("Added 'docs required' label.");
+              }
+            }
+
+            // Fetch the updated labels after any changes
+            const updatedPr = await github.rest.pulls.get({
+              owner,
+              repo,
+              pull_number: prNumber
+            });
+
+            const updatedLabels = updatedPr.data.labels.map(label => label.name);
+            const updatedHasDocsRequired = updatedLabels.includes('docs required');
+            const updatedHasDocsShipped = updatedLabels.includes('docs shipped');
+
+            // Block PR if "docs required" is still present and "docs shipped" is missing
+            if (updatedHasDocsRequired && !updatedHasDocsShipped) {
+              core.setFailed("This PR requires documentation. Please remove the 'docs required' label and add the 'docs shipped' label to proceed.");
+            }

.github/workflows/staging-deployment.yaml

@@ -38,6 +38,7 @@ jobs:
           export DOCKER_TAG="${GITHUB_SHA:0:7}" # needed for child process to access it
           export OTELCOL_TAG="main"
           export PATH="/usr/local/go/bin/:$PATH" # needed for Golang to work
+          export KAFKA_SPAN_EVAL="true"
           docker system prune --force
           docker pull signoz/signoz-otel-collector:main
           docker pull signoz/signoz-schema-migrator:main

deploy/docker-swarm/clickhouse-setup/docker-compose.yaml

@@ -146,7 +146,7 @@ services:
         condition: on-failure
 
   query-service:
-    image: signoz/query-service:0.56.0
+    image: signoz/query-service:0.58.1
     command:
       [
         "-config=/root/config/prometheus.yml",
@@ -186,7 +186,7 @@ services:
     <<: *db-depend
 
   frontend:
-    image: signoz/frontend:0.56.0
+    image: signoz/frontend:0.58.1
     deploy:
       restart_policy:
         condition: on-failure
@@ -199,7 +199,7 @@ services:
       - ../common/nginx-config.conf:/etc/nginx/conf.d/default.conf
 
   otel-collector:
-    image: signoz/signoz-otel-collector:0.102.12
+    image: signoz/signoz-otel-collector:0.111.8
     command:
       [
         "--config=/etc/otel-collector-config.yaml",
@@ -214,7 +214,6 @@ services:
       - /:/hostfs:ro
     environment:
       - OTEL_RESOURCE_ATTRIBUTES=host.name={{.Node.Hostname}},os.type={{.Node.Platform.OS}},dockerswarm.service.name={{.Service.Name}},dockerswarm.task.name={{.Task.Name}}
-      - DOCKER_MULTI_NODE_CLUSTER=false
       - LOW_CARDINAL_EXCEPTION_GROUPING=false
     ports:
       # - "1777:1777"     # pprof extension
@@ -238,7 +237,7 @@ services:
       - query-service
 
   otel-collector-migrator:
-      image: signoz/signoz-schema-migrator:0.102.10
+      image: signoz/signoz-schema-migrator:0.111.8
       deploy:
         restart_policy:
           condition: on-failure

deploy/docker-swarm/clickhouse-setup/otel-collector-config.yaml

@@ -66,28 +66,6 @@ processors:
     # Using OTEL_RESOURCE_ATTRIBUTES envvar, env detector adds custom labels.
     detectors: [env, system] # include ec2 for AWS, gcp for GCP and azure for Azure.
     timeout: 2s
-  signozspanmetrics/cumulative:
-    metrics_exporter: clickhousemetricswrite
-    latency_histogram_buckets: [100us, 1ms, 2ms, 6ms, 10ms, 50ms, 100ms, 250ms, 500ms, 1000ms, 1400ms, 2000ms, 5s, 10s, 20s, 40s, 60s ]
-    dimensions_cache_size: 100000
-    dimensions:
-      - name: service.namespace
-        default: default
-      - name: deployment.environment
-        default: default
-      # This is added to ensure the uniqueness of the timeseries
-      # Otherwise, identical timeseries produced by multiple replicas of
-      # collectors result in incorrect APM metrics
-      - name: signoz.collector.id
-      - name: service.version
-      - name: browser.platform
-      - name: browser.mobile
-      - name: k8s.cluster.name
-      - name: k8s.node.name
-      - name: k8s.namespace.name
-      - name: host.name
-      - name: host.type
-      - name: container.name
   # memory_limiter:
   #   # 80% of maximum memory up to 2G
   #   limit_mib: 1500
@@ -131,7 +109,6 @@ processors:
 exporters:
   clickhousetraces:
     datasource: tcp://clickhouse:9000/signoz_traces
-    docker_multi_node_cluster: ${env:DOCKER_MULTI_NODE_CLUSTER}
     low_cardinal_exception_grouping: ${env:LOW_CARDINAL_EXCEPTION_GROUPING}
   clickhousemetricswrite:
     endpoint: tcp://clickhouse:9000/signoz_metrics
@@ -139,10 +116,11 @@ exporters:
       enabled: true
   clickhousemetricswrite/prometheus:
     endpoint: tcp://clickhouse:9000/signoz_metrics
+  clickhousemetricswritev2:
+    dsn: tcp://clickhouse:9000/signoz_metrics
   # logging: {}
   clickhouselogsexporter:
     dsn: tcp://clickhouse:9000/signoz_logs
-    docker_multi_node_cluster: ${env:DOCKER_MULTI_NODE_CLUSTER}
     timeout: 10s
     use_new_schema: true
 extensions:
@@ -163,20 +141,20 @@ service:
   pipelines:
     traces:
       receivers: [jaeger, otlp]
-      processors: [signozspanmetrics/cumulative, signozspanmetrics/delta, batch]
+      processors: [signozspanmetrics/delta, batch]
       exporters: [clickhousetraces]
     metrics:
       receivers: [otlp]
       processors: [batch]
-      exporters: [clickhousemetricswrite]
-    metrics/generic:
+      exporters: [clickhousemetricswrite, clickhousemetricswritev2]
+    metrics/hostmetrics:
       receivers: [hostmetrics]
       processors: [resourcedetection, batch]
-      exporters: [clickhousemetricswrite]
+      exporters: [clickhousemetricswrite, clickhousemetricswritev2]
     metrics/prometheus:
       receivers: [prometheus]
       processors: [batch]
-      exporters: [clickhousemetricswrite/prometheus]
+      exporters: [clickhousemetricswrite/prometheus, clickhousemetricswritev2]
     logs:
       receivers: [otlp, tcplog/docker]
       processors: [batch]

deploy/docker/clickhouse-setup/docker-compose-core.yaml

@@ -69,7 +69,7 @@ services:
       - --storage.path=/data
 
   otel-collector-migrator:
-    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-0.102.10}
+    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-0.111.8}
     container_name: otel-migrator
     command:
       - "--dsn=tcp://clickhouse:9000"
@@ -84,7 +84,7 @@ services:
   # Notes for Maintainers/Contributors who will change Line Numbers of Frontend & Query-Section. Please Update Line Numbers in `./scripts/commentLinesForSetup.sh` & `./CONTRIBUTING.md`
   otel-collector:
     container_name: signoz-otel-collector
-    image: signoz/signoz-otel-collector:0.102.12
+    image: signoz/signoz-otel-collector:0.111.8
     command:
       [
         "--config=/etc/otel-collector-config.yaml",

deploy/docker/clickhouse-setup/docker-compose-minimal.yaml

@@ -162,7 +162,7 @@ services:
   # Notes for Maintainers/Contributors who will change Line Numbers of Frontend & Query-Section. Please Update Line Numbers in `./scripts/commentLinesForSetup.sh` & `./CONTRIBUTING.md`
 
   query-service:
-    image: signoz/query-service:${DOCKER_TAG:-0.56.0}
+    image: signoz/query-service:${DOCKER_TAG:-0.58.1}
     container_name: signoz-query-service
     command:
       [
@@ -201,7 +201,7 @@ services:
     <<: *db-depend
 
   frontend:
-    image: signoz/frontend:${DOCKER_TAG:-0.56.0}
+    image: signoz/frontend:${DOCKER_TAG:-0.58.1}
     container_name: signoz-frontend
     restart: on-failure
     depends_on:
@@ -213,7 +213,7 @@ services:
       - ../common/nginx-config.conf:/etc/nginx/conf.d/default.conf
 
   otel-collector-migrator-sync:
-    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-0.102.10}
+    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-0.111.8}
     container_name: otel-migrator-sync
     command:
       - "sync"
@@ -228,7 +228,7 @@ services:
       #   condition: service_healthy
 
   otel-collector-migrator-async:
-    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-0.102.10}
+    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-0.111.8}
     container_name: otel-migrator-async
     command:
       - "async"
@@ -245,7 +245,7 @@ services:
       #   condition: service_healthy
 
   otel-collector:
-    image: signoz/signoz-otel-collector:${OTELCOL_TAG:-0.102.12}
+    image: signoz/signoz-otel-collector:${OTELCOL_TAG:-0.111.8}
     container_name: signoz-otel-collector
     command:
       [
@@ -262,7 +262,6 @@ services:
       - /:/hostfs:ro
     environment:
       - OTEL_RESOURCE_ATTRIBUTES=host.name=signoz-host,os.type=linux
-      - DOCKER_MULTI_NODE_CLUSTER=false
       - LOW_CARDINAL_EXCEPTION_GROUPING=false
     ports:
       # - "1777:1777"     # pprof extension

deploy/docker/clickhouse-setup/docker-compose.testing.yaml

@@ -167,7 +167,7 @@ services:
   # Notes for Maintainers/Contributors who will change Line Numbers of Frontend & Query-Section. Please Update Line Numbers in `./scripts/commentLinesForSetup.sh` & `./CONTRIBUTING.md`
 
   query-service:
-    image: signoz/query-service:${DOCKER_TAG:-0.56.0}
+    image: signoz/query-service:${DOCKER_TAG:-0.58.1}
     container_name: signoz-query-service
     command:
       [
@@ -191,6 +191,7 @@ services:
       - GODEBUG=netdns=go
       - TELEMETRY_ENABLED=true
       - DEPLOYMENT_TYPE=docker-standalone-amd
+      - KAFKA_SPAN_EVAL=${KAFKA_SPAN_EVAL:-false}
     restart: on-failure
     healthcheck:
       test:
@@ -207,7 +208,7 @@ services:
     <<: *db-depend
 
   frontend:
-    image: signoz/frontend:${DOCKER_TAG:-0.56.0}
+    image: signoz/frontend:${DOCKER_TAG:-0.58.1}
     container_name: signoz-frontend
     restart: on-failure
     depends_on:
@@ -219,7 +220,7 @@ services:
       - ../common/nginx-config.conf:/etc/nginx/conf.d/default.conf
 
   otel-collector-migrator:
-    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-0.102.10}
+    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-0.111.8}
     container_name: otel-migrator
     command:
       - "--dsn=tcp://clickhouse:9000"
@@ -233,7 +234,7 @@ services:
 
 
   otel-collector:
-    image: signoz/signoz-otel-collector:${OTELCOL_TAG:-0.102.12}
+    image: signoz/signoz-otel-collector:${OTELCOL_TAG:-0.111.8}
     container_name: signoz-otel-collector
     command:
       [
@@ -250,7 +251,6 @@ services:
       - /:/hostfs:ro
     environment:
       - OTEL_RESOURCE_ATTRIBUTES=host.name=signoz-host,os.type=linux
-      - DOCKER_MULTI_NODE_CLUSTER=false
       - LOW_CARDINAL_EXCEPTION_GROUPING=false
     ports:
       # - "1777:1777"     # pprof extension

deploy/docker/clickhouse-setup/otel-collector-config.yaml

@@ -57,35 +57,11 @@ receivers:
             labels:
               job_name: otel-collector
 
-
 processors:
   batch:
     send_batch_size: 10000
     send_batch_max_size: 11000
     timeout: 10s
-  signozspanmetrics/cumulative:
-    metrics_exporter: clickhousemetricswrite
-    metrics_flush_interval: 60s
-    latency_histogram_buckets: [100us, 1ms, 2ms, 6ms, 10ms, 50ms, 100ms, 250ms, 500ms, 1000ms, 1400ms, 2000ms, 5s, 10s, 20s, 40s, 60s ]
-    dimensions_cache_size: 100000
-    dimensions:
-      - name: service.namespace
-        default: default
-      - name: deployment.environment
-        default: default
-      # This is added to ensure the uniqueness of the timeseries
-      # Otherwise, identical timeseries produced by multiple replicas of
-      # collectors result in incorrect APM metrics
-      - name: signoz.collector.id
-      - name: service.version
-      - name: browser.platform
-      - name: browser.mobile
-      - name: k8s.cluster.name
-      - name: k8s.node.name
-      - name: k8s.namespace.name
-      - name: host.name
-      - name: host.type
-      - name: container.name
   # memory_limiter:
   #   # 80% of maximum memory up to 2G
   #   limit_mib: 1500
@@ -142,7 +118,6 @@ extensions:
 exporters:
   clickhousetraces:
     datasource: tcp://clickhouse:9000/signoz_traces
-    docker_multi_node_cluster: ${env:DOCKER_MULTI_NODE_CLUSTER}
     low_cardinal_exception_grouping: ${env:LOW_CARDINAL_EXCEPTION_GROUPING}
   clickhousemetricswrite:
     endpoint: tcp://clickhouse:9000/signoz_metrics
@@ -150,9 +125,10 @@ exporters:
       enabled: true
   clickhousemetricswrite/prometheus:
     endpoint: tcp://clickhouse:9000/signoz_metrics
+  clickhousemetricswritev2:
+    dsn: tcp://clickhouse:9000/signoz_metrics
   clickhouselogsexporter:
     dsn: tcp://clickhouse:9000/signoz_logs
-    docker_multi_node_cluster: ${env:DOCKER_MULTI_NODE_CLUSTER}
     timeout: 10s
     use_new_schema: true
   # logging: {}
@@ -170,20 +146,20 @@ service:
   pipelines:
     traces:
       receivers: [jaeger, otlp]
-      processors: [signozspanmetrics/cumulative, signozspanmetrics/delta, batch]
+      processors: [signozspanmetrics/delta, batch]
       exporters: [clickhousetraces]
     metrics:
       receivers: [otlp]
       processors: [batch]
-      exporters: [clickhousemetricswrite]
-    metrics/generic:
+      exporters: [clickhousemetricswrite, clickhousemetricswritev2]
+    metrics/hostmetrics:
       receivers: [hostmetrics]
       processors: [resourcedetection, batch]
-      exporters: [clickhousemetricswrite]
+      exporters: [clickhousemetricswrite, clickhousemetricswritev2]
     metrics/prometheus:
       receivers: [prometheus]
       processors: [batch]
-      exporters: [clickhousemetricswrite/prometheus]
+      exporters: [clickhousemetricswrite/prometheus, clickhousemetricswritev2]
     logs:
       receivers: [otlp, tcplog/docker]
       processors: [batch]

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

@@ -40,6 +40,7 @@ type APIHandlerOptions struct {
 	// Querier Influx Interval
 	FluxInterval     time.Duration
 	UseLogsNewSchema bool
+	UseLicensesV3    bool
 }
 
 type APIHandler struct {
@@ -65,6 +66,7 @@ func NewAPIHandler(opts APIHandlerOptions) (*APIHandler, error) {
 		Cache:                         opts.Cache,
 		FluxInterval:                  opts.FluxInterval,
 		UseLogsNewSchema:              opts.UseLogsNewSchema,
+		UseLicensesV3:                 opts.UseLicensesV3,
 	})
 
 	if err != nil {
@@ -173,10 +175,25 @@ func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *baseapp.AuthMiddlew
 	router.HandleFunc("/api/v1/dashboards/{uuid}/lock", am.EditAccess(ah.lockDashboard)).Methods(http.MethodPut)
 	router.HandleFunc("/api/v1/dashboards/{uuid}/unlock", am.EditAccess(ah.unlockDashboard)).Methods(http.MethodPut)
 
+	// v2
 	router.HandleFunc("/api/v2/licenses",
 		am.ViewAccess(ah.listLicensesV2)).
 		Methods(http.MethodGet)
 
+	// v3
+	router.HandleFunc("/api/v3/licenses",
+		am.ViewAccess(ah.listLicensesV3)).
+		Methods(http.MethodGet)
+
+	router.HandleFunc("/api/v3/licenses",
+		am.AdminAccess(ah.applyLicenseV3)).
+		Methods(http.MethodPost)
+
+	router.HandleFunc("/api/v3/licenses",
+		am.AdminAccess(ah.refreshLicensesV3)).
+		Methods(http.MethodPut)
+
+	// v4
 	router.HandleFunc("/api/v4/query_range", am.ViewAccess(ah.queryRangeV4)).Methods(http.MethodPost)
 
 	// Gateway

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

@@ -9,6 +9,7 @@ import (
 
 	"go.signoz.io/signoz/ee/query-service/constants"
 	"go.signoz.io/signoz/ee/query-service/model"
+	"go.signoz.io/signoz/pkg/http/render"
 	"go.uber.org/zap"
 )
 
@@ -59,6 +60,21 @@ type billingDetails struct {
 	} `json:"data"`
 }
 
+type ApplyLicenseRequest struct {
+	LicenseKey string `json:"key"`
+}
+
+type ListLicenseResponse map[string]interface{}
+
+func convertLicenseV3ToListLicenseResponse(licensesV3 []*model.LicenseV3) []ListLicenseResponse {
+	listLicenses := []ListLicenseResponse{}
+
+	for _, license := range licensesV3 {
+		listLicenses = append(listLicenses, license.Data)
+	}
+	return listLicenses
+}
+
 func (ah *APIHandler) listLicenses(w http.ResponseWriter, r *http.Request) {
 	licenses, apiError := ah.LM().GetLicenses(context.Background())
 	if apiError != nil {
@@ -88,6 +104,51 @@ func (ah *APIHandler) applyLicense(w http.ResponseWriter, r *http.Request) {
 	ah.Respond(w, license)
 }
 
+func (ah *APIHandler) listLicensesV3(w http.ResponseWriter, r *http.Request) {
+	licenses, apiError := ah.LM().GetLicensesV3(r.Context())
+
+	if apiError != nil {
+		RespondError(w, apiError, nil)
+		return
+	}
+
+	ah.Respond(w, convertLicenseV3ToListLicenseResponse(licenses))
+}
+
+// this function is called by zeus when inserting licenses in the query-service
+func (ah *APIHandler) applyLicenseV3(w http.ResponseWriter, r *http.Request) {
+	var licenseKey ApplyLicenseRequest
+
+	if err := json.NewDecoder(r.Body).Decode(&licenseKey); err != nil {
+		RespondError(w, model.BadRequest(err), nil)
+		return
+	}
+
+	if licenseKey.LicenseKey == "" {
+		RespondError(w, model.BadRequest(fmt.Errorf("license key is required")), nil)
+		return
+	}
+
+	_, apiError := ah.LM().ActivateV3(r.Context(), licenseKey.LicenseKey)
+	if apiError != nil {
+		RespondError(w, apiError, nil)
+		return
+	}
+
+	render.Success(w, http.StatusAccepted, nil)
+}
+
+func (ah *APIHandler) refreshLicensesV3(w http.ResponseWriter, r *http.Request) {
+
+	apiError := ah.LM().RefreshLicense(r.Context())
+	if apiError != nil {
+		RespondError(w, apiError, nil)
+		return
+	}
+
+	render.Success(w, http.StatusNoContent, nil)
+}
+
 func (ah *APIHandler) checkout(w http.ResponseWriter, r *http.Request) {
 
 	type checkoutResponse struct {
@@ -154,11 +215,45 @@ func (ah *APIHandler) getBilling(w http.ResponseWriter, r *http.Request) {
 	ah.Respond(w, billingResponse.Data)
 }
 
+func convertLicenseV3ToLicenseV2(licenses []*model.LicenseV3) []model.License {
+	licensesV2 := []model.License{}
+	for _, l := range licenses {
+		licenseV2 := model.License{
+			Key:               l.Key,
+			ActivationId:      "",
+			PlanDetails:       "",
+			FeatureSet:        l.Features,
+			ValidationMessage: "",
+			IsCurrent:         l.IsCurrent,
+			LicensePlan: model.LicensePlan{
+				PlanKey:    l.PlanName,
+				ValidFrom:  l.ValidFrom,
+				ValidUntil: l.ValidUntil,
+				Status:     l.Status},
+		}
+		licensesV2 = append(licensesV2, licenseV2)
+	}
+	return licensesV2
+}
+
 func (ah *APIHandler) listLicensesV2(w http.ResponseWriter, r *http.Request) {
 
-	licenses, apiError := ah.LM().GetLicenses(context.Background())
-	if apiError != nil {
-		RespondError(w, apiError, nil)
+	var licenses []model.License
+
+	if ah.UseLicensesV3 {
+		licensesV3, err := ah.LM().GetLicensesV3(r.Context())
+		if err != nil {
+			RespondError(w, err, nil)
+			return
+		}
+		licenses = convertLicenseV3ToLicenseV2(licensesV3)
+	} else {
+		_licenses, apiError := ah.LM().GetLicenses(r.Context())
+		if apiError != nil {
+			RespondError(w, apiError, nil)
+			return
+		}
+		licenses = _licenses
 	}
 
 	resp := model.Licenses{

ee/query-service/app/server.go

@@ -31,7 +31,6 @@ import (
 	"go.signoz.io/signoz/ee/query-service/rules"
 	baseauth "go.signoz.io/signoz/pkg/query-service/auth"
 	"go.signoz.io/signoz/pkg/query-service/migrate"
-	"go.signoz.io/signoz/pkg/query-service/model"
 	v3 "go.signoz.io/signoz/pkg/query-service/model/v3"
 
 	licensepkg "go.signoz.io/signoz/ee/query-service/license"
@@ -78,6 +77,7 @@ type ServerOptions struct {
 	Cluster           string
 	GatewayUrl        string
 	UseLogsNewSchema  bool
+	UseLicensesV3     bool
 }
 
 // Server runs HTTP api service
@@ -134,7 +134,7 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 	}
 
 	// initiate license manager
-	lm, err := licensepkg.StartManager("sqlite", localDB)
+	lm, err := licensepkg.StartManager("sqlite", localDB, serverOptions.UseLicensesV3)
 	if err != nil {
 		return nil, err
 	}
@@ -270,6 +270,7 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 		FluxInterval:                  fluxInterval,
 		Gateway:                       gatewayProxy,
 		UseLogsNewSchema:              serverOptions.UseLogsNewSchema,
+		UseLicensesV3:                 serverOptions.UseLicensesV3,
 	}
 
 	apiHandler, err := api.NewAPIHandler(apiOpts)
@@ -348,7 +349,7 @@ func (s *Server) createPublicServer(apiHandler *api.APIHandler) (*http.Server, e
 		}
 
 		if user.User.OrgId == "" {
-			return nil, model.UnauthorizedError(errors.New("orgId is missing in the claims"))
+			return nil, basemodel.UnauthorizedError(errors.New("orgId is missing in the claims"))
 		}
 
 		return user, nil
@@ -765,8 +766,9 @@ func makeRulesManager(
 		Cache:        cache,
 		EvalDelay:    baseconst.GetEvalDelay(),
 
-		PrepareTaskFunc:  rules.PrepareTaskFunc,
-		UseLogsNewSchema: useLogsNewSchema,
+		PrepareTaskFunc:     rules.PrepareTaskFunc,
+		PrepareTestRuleFunc: rules.TestNotification,
+		UseLogsNewSchema:    useLogsNewSchema,
 	}
 
 	// create Manager

ee/query-service/constants/constants.go

@@ -13,6 +13,7 @@ var LicenseAPIKey = GetOrDefaultEnv("SIGNOZ_LICENSE_API_KEY", "")
 var SaasSegmentKey = GetOrDefaultEnv("SIGNOZ_SAAS_SEGMENT_KEY", "")
 var FetchFeatures = GetOrDefaultEnv("FETCH_FEATURES", "false")
 var ZeusFeaturesURL = GetOrDefaultEnv("ZEUS_FEATURES_URL", "ZeusFeaturesURL")
+var ZeusURL = GetOrDefaultEnv("ZEUS_URL", "ZeusURL")
 
 func GetOrDefaultEnv(key string, fallback string) string {
 	v := os.Getenv(key)

ee/query-service/integrations/gateway/proxy.go

@@ -9,8 +9,8 @@ import (
 )
 
 var (
-	RoutePrefix   string = "/api/gateway"
-	AllowedPrefix []string = []string{"/v1/workspaces/me", "/v2/profiles/me"}
+	RoutePrefix   string   = "/api/gateway"
+	AllowedPrefix []string = []string{"/v1/workspaces/me", "/v2/profiles/me", "/v2/deployments/me"}
 )
 
 type proxy struct {

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

@@ -13,3 +13,8 @@ type ActivationResponse struct {
 	ActivationId string `json:"ActivationId"`
 	PlanDetails  string `json:"PlanDetails"`
 }
+
+type ValidateLicenseResponse struct {
+	Status status                 `json:"status"`
+	Data   map[string]interface{} `json:"data"`
+}

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

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"time"
 
 	"github.com/pkg/errors"
 	"go.uber.org/zap"
@@ -23,12 +24,14 @@ const (
 )
 
 type Client struct {
-	Prefix string
+	Prefix     string
+	GatewayUrl string
 }
 
 func New() *Client {
 	return &Client{
-		Prefix: constants.LicenseSignozIo,
+		Prefix:     constants.LicenseSignozIo,
+		GatewayUrl: constants.ZeusURL,
 	}
 }
 
@@ -116,6 +119,60 @@ func ValidateLicense(activationId string) (*ActivationResponse, *model.ApiError)
 
 }
 
+func ValidateLicenseV3(licenseKey string) (*model.LicenseV3, *model.ApiError) {
+
+	// Creating an HTTP client with a timeout for better control
+	client := &http.Client{
+		Timeout: 10 * time.Second,
+	}
+
+	req, err := http.NewRequest("GET", C.GatewayUrl+"/v2/licenses/me", nil)
+	if err != nil {
+		return nil, model.BadRequest(errors.Wrap(err, fmt.Sprintf("failed to create request: %w", err)))
+	}
+
+	// Setting the custom header
+	req.Header.Set("X-Signoz-Cloud-Api-Key", licenseKey)
+
+	response, err := client.Do(req)
+	if err != nil {
+		return nil, model.BadRequest(errors.Wrap(err, fmt.Sprintf("failed to make post request: %w", err)))
+	}
+
+	body, err := io.ReadAll(response.Body)
+	if err != nil {
+		return nil, model.BadRequest(errors.Wrap(err, fmt.Sprintf("failed to read validation response from %v", C.GatewayUrl)))
+	}
+
+	defer response.Body.Close()
+
+	switch response.StatusCode {
+	case 200:
+		a := ValidateLicenseResponse{}
+		err = json.Unmarshal(body, &a)
+		if err != nil {
+			return nil, model.BadRequest(errors.Wrap(err, "failed to marshal license validation response"))
+		}
+
+		license, err := model.NewLicenseV3(a.Data)
+		if err != nil {
+			return nil, model.BadRequest(errors.Wrap(err, "failed to generate new license v3"))
+		}
+
+		return license, nil
+	case 400:
+		return nil, model.BadRequest(errors.Wrap(fmt.Errorf(string(body)),
+			fmt.Sprintf("bad request error received from %v", C.GatewayUrl)))
+	case 401:
+		return nil, model.Unauthorized(errors.Wrap(fmt.Errorf(string(body)),
+			fmt.Sprintf("unauthorized request error received from %v", C.GatewayUrl)))
+	default:
+		return nil, model.InternalError(errors.Wrap(fmt.Errorf(string(body)),
+			fmt.Sprintf("internal request error received from %v", C.GatewayUrl)))
+	}
+
+}
+
 func NewPostRequestWithCtx(ctx context.Context, url string, contentType string, body io.Reader) (*http.Request, error) {
 	req, err := http.NewRequestWithContext(ctx, POST, url, body)
 	if err != nil {

ee/query-service/license/db.go

@@ -3,10 +3,12 @@ package license
 import (
 	"context"
 	"database/sql"
+	"encoding/json"
 	"fmt"
 	"time"
 
 	"github.com/jmoiron/sqlx"
+	"github.com/mattn/go-sqlite3"
 
 	"go.signoz.io/signoz/ee/query-service/license/sqlite"
 	"go.signoz.io/signoz/ee/query-service/model"
@@ -48,6 +50,34 @@ func (r *Repo) GetLicenses(ctx context.Context) ([]model.License, error) {
 	return licenses, nil
 }
 
+func (r *Repo) GetLicensesV3(ctx context.Context) ([]*model.LicenseV3, error) {
+	licensesData := []model.LicenseDB{}
+	licenseV3Data := []*model.LicenseV3{}
+
+	query := "SELECT id,key,data FROM licenses_v3"
+
+	err := r.db.Select(&licensesData, query)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get licenses from db: %v", err)
+	}
+
+	for _, l := range licensesData {
+		var licenseData map[string]interface{}
+		err := json.Unmarshal([]byte(l.Data), &licenseData)
+		if err != nil {
+			return nil, fmt.Errorf("failed to unmarshal data into licenseData : %v", err)
+		}
+
+		license, err := model.NewLicenseV3WithIDAndKey(l.ID, l.Key, licenseData)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get licenses v3 schema : %v", err)
+		}
+		licenseV3Data = append(licenseV3Data, license)
+	}
+
+	return licenseV3Data, nil
+}
+
 // GetActiveLicense fetches the latest active license from DB.
 // If the license is not present, expect a nil license and a nil error in the output.
 func (r *Repo) GetActiveLicense(ctx context.Context) (*model.License, *basemodel.ApiError) {
@@ -79,6 +109,45 @@ func (r *Repo) GetActiveLicense(ctx context.Context) (*model.License, *basemodel
 	return active, nil
 }
 
+func (r *Repo) GetActiveLicenseV3(ctx context.Context) (*model.LicenseV3, error) {
+	var err error
+	licenses := []model.LicenseDB{}
+
+	query := "SELECT id,key,data FROM licenses_v3"
+
+	err = r.db.Select(&licenses, query)
+	if err != nil {
+		return nil, basemodel.InternalError(fmt.Errorf("failed to get active licenses from db: %v", err))
+	}
+
+	var active *model.LicenseV3
+	for _, l := range licenses {
+		var licenseData map[string]interface{}
+		err := json.Unmarshal([]byte(l.Data), &licenseData)
+		if err != nil {
+			return nil, fmt.Errorf("failed to unmarshal data into licenseData : %v", err)
+		}
+
+		license, err := model.NewLicenseV3WithIDAndKey(l.ID, l.Key, licenseData)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get licenses v3 schema : %v", err)
+		}
+
+		if active == nil &&
+			(license.ValidFrom != 0) &&
+			(license.ValidUntil == -1 || license.ValidUntil > time.Now().Unix()) {
+			active = license
+		}
+		if active != nil &&
+			license.ValidFrom > active.ValidFrom &&
+			(license.ValidUntil == -1 || license.ValidUntil > time.Now().Unix()) {
+			active = license
+		}
+	}
+
+	return active, nil
+}
+
 // InsertLicense inserts a new license in db
 func (r *Repo) InsertLicense(ctx context.Context, l *model.License) error {
 
@@ -204,3 +273,59 @@ func (r *Repo) InitFeatures(req basemodel.FeatureSet) error {
 	}
 	return nil
 }
+
+// InsertLicenseV3 inserts a new license v3 in db
+func (r *Repo) InsertLicenseV3(ctx context.Context, l *model.LicenseV3) *model.ApiError {
+
+	query := `INSERT INTO licenses_v3 (id, key, data) VALUES ($1, $2, $3)`
+
+	// licsense is the entity of zeus so putting the entire license here without defining schema
+	licenseData, err := json.Marshal(l.Data)
+	if err != nil {
+		return &model.ApiError{Typ: basemodel.ErrorBadData, Err: err}
+	}
+
+	_, err = r.db.ExecContext(ctx,
+		query,
+		l.ID,
+		l.Key,
+		string(licenseData),
+	)
+
+	if err != nil {
+		if sqliteErr, ok := err.(sqlite3.Error); ok {
+			if sqliteErr.ExtendedCode == sqlite3.ErrConstraintUnique {
+				zap.L().Error("error in inserting license data: ", zap.Error(sqliteErr))
+				return &model.ApiError{Typ: model.ErrorConflict, Err: sqliteErr}
+			}
+		}
+		zap.L().Error("error in inserting license data: ", zap.Error(err))
+		return &model.ApiError{Typ: basemodel.ErrorExec, Err: err}
+	}
+
+	return nil
+}
+
+// UpdateLicenseV3 updates a new license v3 in db
+func (r *Repo) UpdateLicenseV3(ctx context.Context, l *model.LicenseV3) error {
+
+	// the key and id for the license can't change so only update the data here!
+	query := `UPDATE licenses_v3 SET data=$1 WHERE id=$2;`
+
+	license, err := json.Marshal(l.Data)
+	if err != nil {
+		return fmt.Errorf("insert license failed: license marshal error")
+	}
+	_, err = r.db.ExecContext(ctx,
+		query,
+		license,
+		l.ID,
+	)
+
+	if err != nil {
+		zap.L().Error("error in updating license data: ", zap.Error(err))
+		return fmt.Errorf("failed to update license in db: %v", err)
+	}
+
+	return nil
+}

ee/query-service/license/manager.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/jmoiron/sqlx"
+	"github.com/pkg/errors"
 
 	"sync"
 
@@ -45,11 +46,12 @@ type Manager struct {
 	failedAttempts uint64
 
 	// keep track of active license and features
-	activeLicense  *model.License
-	activeFeatures basemodel.FeatureSet
+	activeLicense   *model.License
+	activeLicenseV3 *model.LicenseV3
+	activeFeatures  basemodel.FeatureSet
 }
 
-func StartManager(dbType string, db *sqlx.DB, features ...basemodel.Feature) (*Manager, error) {
+func StartManager(dbType string, db *sqlx.DB, useLicensesV3 bool, features ...basemodel.Feature) (*Manager, error) {
 	if LM != nil {
 		return LM, nil
 	}
@@ -65,7 +67,7 @@ func StartManager(dbType string, db *sqlx.DB, features ...basemodel.Feature) (*M
 		repo: &repo,
 	}
 
-	if err := m.start(features...); err != nil {
+	if err := m.start(useLicensesV3, features...); err != nil {
 		return m, err
 	}
 	LM = m
@@ -73,8 +75,14 @@ func StartManager(dbType string, db *sqlx.DB, features ...basemodel.Feature) (*M
 }
 
 // start loads active license in memory and initiates validator
-func (lm *Manager) start(features ...basemodel.Feature) error {
-	err := lm.LoadActiveLicense(features...)
+func (lm *Manager) start(useLicensesV3 bool, features ...basemodel.Feature) error {
+
+	var err error
+	if useLicensesV3 {
+		err = lm.LoadActiveLicenseV3(features...)
+	} else {
+		err = lm.LoadActiveLicense(features...)
+	}
 
 	return err
 }
@@ -108,6 +116,31 @@ func (lm *Manager) SetActive(l *model.License, features ...basemodel.Feature) {
 		go lm.Validator(context.Background())
 	}
 
+}
+func (lm *Manager) SetActiveV3(l *model.LicenseV3, features ...basemodel.Feature) {
+	lm.mutex.Lock()
+	defer lm.mutex.Unlock()
+
+	if l == nil {
+		return
+	}
+
+	lm.activeLicenseV3 = l
+	lm.activeFeatures = append(l.Features, features...)
+	// set default features
+	setDefaultFeatures(lm)
+
+	err := lm.InitFeatures(lm.activeFeatures)
+	if err != nil {
+		zap.L().Panic("Couldn't activate features", zap.Error(err))
+	}
+	if !lm.validatorRunning {
+		// we want to make sure only one validator runs,
+		// we already have lock() so good to go
+		lm.validatorRunning = true
+		go lm.ValidatorV3(context.Background())
+	}
+
 }
 
 func setDefaultFeatures(lm *Manager) {
@@ -137,6 +170,28 @@ func (lm *Manager) LoadActiveLicense(features ...basemodel.Feature) error {
 	return nil
 }
 
+func (lm *Manager) LoadActiveLicenseV3(features ...basemodel.Feature) error {
+	active, err := lm.repo.GetActiveLicenseV3(context.Background())
+	if err != nil {
+		return err
+	}
+	if active != nil {
+		lm.SetActiveV3(active, features...)
+	} else {
+		zap.L().Info("No active license found, defaulting to basic plan")
+		// if no active license is found, we default to basic(free) plan with all default features
+		lm.activeFeatures = model.BasicPlan
+		setDefaultFeatures(lm)
+		err := lm.InitFeatures(lm.activeFeatures)
+		if err != nil {
+			zap.L().Error("Couldn't initialize features", zap.Error(err))
+			return err
+		}
+	}
+
+	return nil
+}
+
 func (lm *Manager) GetLicenses(ctx context.Context) (response []model.License, apiError *model.ApiError) {
 
 	licenses, err := lm.repo.GetLicenses(ctx)
@@ -163,6 +218,23 @@ func (lm *Manager) GetLicenses(ctx context.Context) (response []model.License, a
 	return
 }
 
+func (lm *Manager) GetLicensesV3(ctx context.Context) (response []*model.LicenseV3, apiError *model.ApiError) {
+
+	licenses, err := lm.repo.GetLicensesV3(ctx)
+	if err != nil {
+		return nil, model.InternalError(err)
+	}
+
+	for _, l := range licenses {
+		if lm.activeLicenseV3 != nil && l.Key == lm.activeLicenseV3.Key {
+			l.IsCurrent = true
+		}
+		response = append(response, l)
+	}
+
+	return response, nil
+}
+
 // Validator validates license after an epoch of time
 func (lm *Manager) Validator(ctx context.Context) {
 	defer close(lm.terminated)
@@ -187,6 +259,30 @@ func (lm *Manager) Validator(ctx context.Context) {
 	}
 }
 
+// Validator validates license after an epoch of time
+func (lm *Manager) ValidatorV3(ctx context.Context) {
+	defer close(lm.terminated)
+	tick := time.NewTicker(validationFrequency)
+	defer tick.Stop()
+
+	lm.ValidateV3(ctx)
+
+	for {
+		select {
+		case <-lm.done:
+			return
+		default:
+			select {
+			case <-lm.done:
+				return
+			case <-tick.C:
+				lm.ValidateV3(ctx)
+			}
+		}
+
+	}
+}
+
 // Validate validates the current active license
 func (lm *Manager) Validate(ctx context.Context) (reterr error) {
 	zap.L().Info("License validation started")
@@ -254,6 +350,54 @@ func (lm *Manager) Validate(ctx context.Context) (reterr error) {
 	return nil
 }
 
+// todo[vikrantgupta25]: check the comparison here between old and new license!
+func (lm *Manager) RefreshLicense(ctx context.Context) *model.ApiError {
+
+	license, apiError := validate.ValidateLicenseV3(lm.activeLicenseV3.Key)
+	if apiError != nil {
+		zap.L().Error("failed to validate license", zap.Error(apiError.Err))
+		return apiError
+	}
+
+	err := lm.repo.UpdateLicenseV3(ctx, license)
+	if err != nil {
+		return model.BadRequest(errors.Wrap(err, "failed to update the new license"))
+	}
+	lm.SetActiveV3(license)
+
+	return nil
+}
+
+func (lm *Manager) ValidateV3(ctx context.Context) (reterr error) {
+	zap.L().Info("License validation started")
+	if lm.activeLicenseV3 == nil {
+		return nil
+	}
+
+	defer func() {
+		lm.mutex.Lock()
+
+		lm.lastValidated = time.Now().Unix()
+		if reterr != nil {
+			zap.L().Error("License validation completed with error", zap.Error(reterr))
+			atomic.AddUint64(&lm.failedAttempts, 1)
+			telemetry.GetInstance().SendEvent(telemetry.TELEMETRY_LICENSE_CHECK_FAILED,
+				map[string]interface{}{"err": reterr.Error()}, "", true, false)
+		} else {
+			zap.L().Info("License validation completed with no errors")
+		}
+
+		lm.mutex.Unlock()
+	}()
+
+	err := lm.RefreshLicense(ctx)
+
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
 // Activate activates a license key with signoz server
 func (lm *Manager) Activate(ctx context.Context, key string) (licenseResponse *model.License, errResponse *model.ApiError) {
 	defer func() {
@@ -298,6 +442,35 @@ func (lm *Manager) Activate(ctx context.Context, key string) (licenseResponse *m
 	return l, nil
 }
 
+func (lm *Manager) ActivateV3(ctx context.Context, licenseKey string) (licenseResponse *model.LicenseV3, errResponse *model.ApiError) {
+	defer func() {
+		if errResponse != nil {
+			userEmail, err := auth.GetEmailFromJwt(ctx)
+			if err == nil {
+				telemetry.GetInstance().SendEvent(telemetry.TELEMETRY_LICENSE_ACT_FAILED,
+					map[string]interface{}{"err": errResponse.Err.Error()}, userEmail, true, false)
+			}
+		}
+	}()
+
+	license, apiError := validate.ValidateLicenseV3(licenseKey)
+	if apiError != nil {
+		zap.L().Error("failed to get the license", zap.Error(apiError.Err))
+		return nil, apiError
+	}
+
+	// insert the new license to the sqlite db
+	err := lm.repo.InsertLicenseV3(ctx, license)
+	if err != nil {
+		zap.L().Error("failed to activate license", zap.Error(err))
+		return nil, err
+	}
+
+	// license is valid, activate it
+	lm.SetActiveV3(license)
+	return license, nil
+}
+
 // CheckFeature will be internally used by backend routines
 // for feature gating
 func (lm *Manager) CheckFeature(featureKey string) error {

ee/query-service/license/sqlite/init.go

@@ -48,5 +48,16 @@ func InitDB(db *sqlx.DB) error {
 		return fmt.Errorf("error in creating feature_status table: %s", err.Error())
 	}
 
+	table_schema = `CREATE TABLE IF NOT EXISTS licenses_v3 (
+		id TEXT PRIMARY KEY,
+		key TEXT NOT NULL UNIQUE,
+		data TEXT
+	);`
+
+	_, err = db.Exec(table_schema)
+	if err != nil {
+		return fmt.Errorf("error in creating licenses_v3 table: %s", err.Error())
+	}
+
 	return nil
 }

ee/query-service/main.go

@@ -94,6 +94,7 @@ func main() {
 	var cluster string
 
 	var useLogsNewSchema bool
+	var useLicensesV3 bool
 	var cacheConfigPath, fluxInterval string
 	var enableQueryServiceLogOTLPExport bool
 	var preferSpanMetrics bool
@@ -104,6 +105,7 @@ func main() {
 	var gatewayUrl string
 
 	flag.BoolVar(&useLogsNewSchema, "use-logs-new-schema", false, "use logs_v2 schema for logs")
+	flag.BoolVar(&useLicensesV3, "use-licenses-v3", false, "use licenses_v3 schema for licenses")
 	flag.StringVar(&promConfigPath, "config", "./config/prometheus.yml", "(prometheus config to read metrics)")
 	flag.StringVar(&skipTopLvlOpsPath, "skip-top-level-ops", "", "(config file to skip top level operations)")
 	flag.BoolVar(&disableRules, "rules.disable", false, "(disable rule evaluation)")
@@ -143,6 +145,7 @@ func main() {
 		Cluster:           cluster,
 		GatewayUrl:        gatewayUrl,
 		UseLogsNewSchema:  useLogsNewSchema,
+		UseLicensesV3:     useLicensesV3,
 	}
 
 	// Read the jwt secret key

ee/query-service/model/errors.go

@@ -46,6 +46,13 @@ func BadRequest(err error) *ApiError {
 	}
 }
 
+func Unauthorized(err error) *ApiError {
+	return &ApiError{
+		Typ: basemodel.ErrorUnauthorized,
+		Err: err,
+	}
+}
+
 // BadRequestStr returns a ApiError object of bad request for string input
 func BadRequestStr(s string) *ApiError {
 	return &ApiError{

ee/query-service/model/license.go

@@ -3,6 +3,8 @@ package model
 import (
 	"encoding/base64"
 	"encoding/json"
+	"fmt"
+	"reflect"
 	"time"
 
 	"github.com/pkg/errors"
@@ -104,3 +106,144 @@ type SubscriptionServerResp struct {
 	Status string   `json:"status"`
 	Data   Licenses `json:"data"`
 }
+
+type Plan struct {
+	Name string `json:"name"`
+}
+
+type LicenseDB struct {
+	ID   string `json:"id"`
+	Key  string `json:"key"`
+	Data string `json:"data"`
+}
+type LicenseV3 struct {
+	ID         string
+	Key        string
+	Data       map[string]interface{}
+	PlanName   string
+	Features   basemodel.FeatureSet
+	Status     string
+	IsCurrent  bool
+	ValidFrom  int64
+	ValidUntil int64
+}
+
+func extractKeyFromMapStringInterface[T any](data map[string]interface{}, key string) (T, error) {
+	var zeroValue T
+	if val, ok := data[key]; ok {
+		if value, ok := val.(T); ok {
+			return value, nil
+		}
+		return zeroValue, fmt.Errorf("%s key is not a valid %s", key, reflect.TypeOf(zeroValue))
+	}
+	return zeroValue, fmt.Errorf("%s key is missing", key)
+}
+
+func NewLicenseV3(data map[string]interface{}) (*LicenseV3, error) {
+	var features basemodel.FeatureSet
+
+	// extract id from data
+	licenseID, err := extractKeyFromMapStringInterface[string](data, "id")
+	if err != nil {
+		return nil, err
+	}
+	delete(data, "id")
+
+	// extract key from data
+	licenseKey, err := extractKeyFromMapStringInterface[string](data, "key")
+	if err != nil {
+		return nil, err
+	}
+	delete(data, "key")
+
+	// extract status from data
+	status, err := extractKeyFromMapStringInterface[string](data, "status")
+	if err != nil {
+		return nil, err
+	}
+
+	planMap, err := extractKeyFromMapStringInterface[map[string]any](data, "plan")
+	if err != nil {
+		return nil, err
+	}
+
+	planName, err := extractKeyFromMapStringInterface[string](planMap, "name")
+	if err != nil {
+		return nil, err
+	}
+	// if license status is inactive then default it to basic
+	if status == LicenseStatusInactive {
+		planName = PlanNameBasic
+	}
+
+	featuresFromZeus := basemodel.FeatureSet{}
+	if _features, ok := data["features"]; ok {
+		featuresData, err := json.Marshal(_features)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to marshal features data")
+		}
+
+		if err := json.Unmarshal(featuresData, &featuresFromZeus); err != nil {
+			return nil, errors.Wrap(err, "failed to unmarshal features data")
+		}
+	}
+
+	switch planName {
+	case PlanNameTeams:
+		features = append(features, ProPlan...)
+	case PlanNameEnterprise:
+		features = append(features, EnterprisePlan...)
+	case PlanNameBasic:
+		features = append(features, BasicPlan...)
+	default:
+		features = append(features, BasicPlan...)
+	}
+
+	if len(featuresFromZeus) > 0 {
+		for _, feature := range featuresFromZeus {
+			exists := false
+			for i, existingFeature := range features {
+				if existingFeature.Name == feature.Name {
+					features[i] = feature // Replace existing feature
+					exists = true
+					break
+				}
+			}
+			if !exists {
+				features = append(features, feature) // Append if it doesn't exist
+			}
+		}
+	}
+	data["features"] = features
+
+	_validFrom, err := extractKeyFromMapStringInterface[float64](data, "valid_from")
+	if err != nil {
+		_validFrom = 0
+	}
+	validFrom := int64(_validFrom)
+
+	_validUntil, err := extractKeyFromMapStringInterface[float64](data, "valid_until")
+	if err != nil {
+		_validUntil = 0
+	}
+	validUntil := int64(_validUntil)
+
+	return &LicenseV3{
+		ID:         licenseID,
+		Key:        licenseKey,
+		Data:       data,
+		PlanName:   planName,
+		Features:   features,
+		ValidFrom:  validFrom,
+		ValidUntil: validUntil,
+		Status:     status,
+	}, nil
+
+}
+
+func NewLicenseV3WithIDAndKey(id string, key string, data map[string]interface{}) (*LicenseV3, error) {
+	licenseDataWithIdAndKey := data
+	licenseDataWithIdAndKey["id"] = id
+	licenseDataWithIdAndKey["key"] = key
+	return NewLicenseV3(licenseDataWithIdAndKey)
+}

ee/query-service/model/license_test.go

@@ -0,0 +1,170 @@
+package model
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.signoz.io/signoz/pkg/query-service/model"
+)
+
+func TestNewLicenseV3(t *testing.T) {
+	testCases := []struct {
+		name     string
+		data     []byte
+		pass     bool
+		expected *LicenseV3
+		error    error
+	}{
+		{
+			name:  "Error for missing license id",
+			data:  []byte(`{}`),
+			pass:  false,
+			error: errors.New("id key is missing"),
+		},
+		{
+			name:  "Error for license id not being a valid string",
+			data:  []byte(`{"id": 10}`),
+			pass:  false,
+			error: errors.New("id key is not a valid string"),
+		},
+		{
+			name:  "Error for missing license key",
+			data:  []byte(`{"id":"does-not-matter"}`),
+			pass:  false,
+			error: errors.New("key key is missing"),
+		},
+		{
+			name:  "Error for invalid string license key",
+			data:  []byte(`{"id":"does-not-matter","key":10}`),
+			pass:  false,
+			error: errors.New("key key is not a valid string"),
+		},
+		{
+			name:  "Error for missing license status",
+			data:  []byte(`{"id":"does-not-matter", "key": "does-not-matter","category":"FREE"}`),
+			pass:  false,
+			error: errors.New("status key is missing"),
+		},
+		{
+			name:  "Error for invalid string license status",
+			data:  []byte(`{"id":"does-not-matter","key": "does-not-matter", "category":"FREE", "status":10}`),
+			pass:  false,
+			error: errors.New("status key is not a valid string"),
+		},
+		{
+			name:  "Error for missing license plan",
+			data:  []byte(`{"id":"does-not-matter","key":"does-not-matter-key","category":"FREE","status":"ACTIVE"}`),
+			pass:  false,
+			error: errors.New("plan key is missing"),
+		},
+		{
+			name:  "Error for invalid json license plan",
+			data:  []byte(`{"id":"does-not-matter","key":"does-not-matter-key","category":"FREE","status":"ACTIVE","plan":10}`),
+			pass:  false,
+			error: errors.New("plan key is not a valid map[string]interface {}"),
+		},
+		{
+			name:  "Error for invalid license plan",
+			data:  []byte(`{"id":"does-not-matter","key":"does-not-matter-key","category":"FREE","status":"ACTIVE","plan":{}}`),
+			pass:  false,
+			error: errors.New("name key is missing"),
+		},
+		{
+			name: "Parse the entire license properly",
+			data: []byte(`{"id":"does-not-matter","key":"does-not-matter-key","category":"FREE","status":"ACTIVE","plan":{"name":"TEAMS"},"valid_from": 1730899309,"valid_until": -1}`),
+			pass: true,
+			expected: &LicenseV3{
+				ID:  "does-not-matter",
+				Key: "does-not-matter-key",
+				Data: map[string]interface{}{
+					"plan": map[string]interface{}{
+						"name": "TEAMS",
+					},
+					"category":    "FREE",
+					"status":      "ACTIVE",
+					"valid_from":  float64(1730899309),
+					"valid_until": float64(-1),
+				},
+				PlanName:   PlanNameTeams,
+				ValidFrom:  1730899309,
+				ValidUntil: -1,
+				Status:     "ACTIVE",
+				IsCurrent:  false,
+				Features:   model.FeatureSet{},
+			},
+		},
+		{
+			name: "Fallback to basic plan if license status is inactive",
+			data: []byte(`{"id":"does-not-matter","key":"does-not-matter-key","category":"FREE","status":"INACTIVE","plan":{"name":"TEAMS"},"valid_from": 1730899309,"valid_until": -1}`),
+			pass: true,
+			expected: &LicenseV3{
+				ID:  "does-not-matter",
+				Key: "does-not-matter-key",
+				Data: map[string]interface{}{
+					"plan": map[string]interface{}{
+						"name": "TEAMS",
+					},
+					"category":    "FREE",
+					"status":      "INACTIVE",
+					"valid_from":  float64(1730899309),
+					"valid_until": float64(-1),
+				},
+				PlanName:   PlanNameBasic,
+				ValidFrom:  1730899309,
+				ValidUntil: -1,
+				Status:     "INACTIVE",
+				IsCurrent:  false,
+				Features:   model.FeatureSet{},
+			},
+		},
+		{
+			name: "fallback states for validFrom and validUntil",
+			data: []byte(`{"id":"does-not-matter","key":"does-not-matter-key","category":"FREE","status":"ACTIVE","plan":{"name":"TEAMS"},"valid_from":1234.456,"valid_until":5678.567}`),
+			pass: true,
+			expected: &LicenseV3{
+				ID:  "does-not-matter",
+				Key: "does-not-matter-key",
+				Data: map[string]interface{}{
+					"plan": map[string]interface{}{
+						"name": "TEAMS",
+					},
+					"valid_from":  1234.456,
+					"valid_until": 5678.567,
+					"category":    "FREE",
+					"status":      "ACTIVE",
+				},
+				PlanName:   PlanNameTeams,
+				ValidFrom:  1234,
+				ValidUntil: 5678,
+				Status:     "ACTIVE",
+				IsCurrent:  false,
+				Features:   model.FeatureSet{},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		var licensePayload map[string]interface{}
+		err := json.Unmarshal(tc.data, &licensePayload)
+		require.NoError(t, err)
+		license, err := NewLicenseV3(licensePayload)
+		if license != nil {
+			license.Features = make(model.FeatureSet, 0)
+			delete(license.Data, "features")
+		}
+
+		if tc.pass {
+			require.NoError(t, err)
+			require.NotNil(t, license)
+			assert.Equal(t, tc.expected, license)
+		} else {
+			require.Error(t, err)
+			assert.EqualError(t, err, tc.error.Error())
+			require.Nil(t, license)
+		}
+
+	}
+}

ee/query-service/model/plans.go

@@ -1,6 +1,7 @@
 package model
 
 import (
+	"go.signoz.io/signoz/pkg/query-service/constants"
 	basemodel "go.signoz.io/signoz/pkg/query-service/model"
 )
 
@@ -8,6 +9,17 @@ const SSO = "SSO"
 const Basic = "BASIC_PLAN"
 const Pro = "PRO_PLAN"
 const Enterprise = "ENTERPRISE_PLAN"
+
+var (
+	PlanNameEnterprise = "ENTERPRISE"
+	PlanNameTeams      = "TEAMS"
+	PlanNameBasic      = "BASIC"
+)
+
+var (
+	LicenseStatusInactive = "INACTIVE"
+)
+
 const DisableUpsell = "DISABLE_UPSELL"
 const Onboarding = "ONBOARDING"
 const ChatSupport = "CHAT_SUPPORT"
@@ -134,6 +146,13 @@ var BasicPlan = basemodel.FeatureSet{
 		UsageLimit: -1,
 		Route:      "",
 	},
+	basemodel.Feature{
+		Name:       basemodel.HostsInfraMonitoring,
+		Active:     constants.EnableHostsInfraMonitoring(),
+		Usage:      0,
+		UsageLimit: -1,
+		Route:      "",
+	},
 }
 
 var ProPlan = basemodel.FeatureSet{
@@ -249,6 +268,13 @@ var ProPlan = basemodel.FeatureSet{
 		UsageLimit: -1,
 		Route:      "",
 	},
+	basemodel.Feature{
+		Name:       basemodel.HostsInfraMonitoring,
+		Active:     constants.EnableHostsInfraMonitoring(),
+		Usage:      0,
+		UsageLimit: -1,
+		Route:      "",
+	},
 }
 
 var EnterprisePlan = basemodel.FeatureSet{
@@ -378,4 +404,11 @@ var EnterprisePlan = basemodel.FeatureSet{
 		UsageLimit: -1,
 		Route:      "",
 	},
+	basemodel.Feature{
+		Name:       basemodel.HostsInfraMonitoring,
+		Active:     constants.EnableHostsInfraMonitoring(),
+		Usage:      0,
+		UsageLimit: -1,
+		Route:      "",
+	},
 }

ee/query-service/rules/manager.go

@@ -1,10 +1,15 @@
 package rules
 
 import (
+	"context"
 	"fmt"
 	"time"
 
+	"github.com/google/uuid"
+	basemodel "go.signoz.io/signoz/pkg/query-service/model"
 	baserules "go.signoz.io/signoz/pkg/query-service/rules"
+	"go.signoz.io/signoz/pkg/query-service/utils/labels"
+	"go.uber.org/zap"
 )
 
 func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error) {
@@ -79,6 +84,106 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 	return task, nil
 }
 
+// TestNotification prepares a dummy rule for given rule parameters and
+// sends a test notification. returns alert count and error (if any)
+func TestNotification(opts baserules.PrepareTestRuleOptions) (int, *basemodel.ApiError) {
+
+	ctx := context.Background()
+
+	if opts.Rule == nil {
+		return 0, basemodel.BadRequest(fmt.Errorf("rule is required"))
+	}
+
+	parsedRule := opts.Rule
+	var alertname = parsedRule.AlertName
+	if alertname == "" {
+		// alertname is not mandatory for testing, so picking
+		// a random string here
+		alertname = uuid.New().String()
+	}
+
+	// append name to indicate this is test alert
+	parsedRule.AlertName = fmt.Sprintf("%s%s", alertname, baserules.TestAlertPostFix)
+
+	var rule baserules.Rule
+	var err error
+
+	if parsedRule.RuleType == baserules.RuleTypeThreshold {
+
+		// add special labels for test alerts
+		parsedRule.Annotations[labels.AlertSummaryLabel] = fmt.Sprintf("The rule threshold is set to %.4f, and the observed metric value is {{$value}}.", *parsedRule.RuleCondition.Target)
+		parsedRule.Labels[labels.RuleSourceLabel] = ""
+		parsedRule.Labels[labels.AlertRuleIdLabel] = ""
+
+		// create a threshold rule
+		rule, err = baserules.NewThresholdRule(
+			alertname,
+			parsedRule,
+			opts.FF,
+			opts.Reader,
+			opts.UseLogsNewSchema,
+			baserules.WithSendAlways(),
+			baserules.WithSendUnmatched(),
+		)
+
+		if err != nil {
+			zap.L().Error("failed to prepare a new threshold rule for test", zap.String("name", rule.Name()), zap.Error(err))
+			return 0, basemodel.BadRequest(err)
+		}
+
+	} else if parsedRule.RuleType == baserules.RuleTypeProm {
+
+		// create promql rule
+		rule, err = baserules.NewPromRule(
+			alertname,
+			parsedRule,
+			opts.Logger,
+			opts.Reader,
+			opts.ManagerOpts.PqlEngine,
+			baserules.WithSendAlways(),
+			baserules.WithSendUnmatched(),
+		)
+
+		if err != nil {
+			zap.L().Error("failed to prepare a new promql rule for test", zap.String("name", rule.Name()), zap.Error(err))
+			return 0, basemodel.BadRequest(err)
+		}
+	} else if parsedRule.RuleType == baserules.RuleTypeAnomaly {
+		// create anomaly rule
+		rule, err = NewAnomalyRule(
+			alertname,
+			parsedRule,
+			opts.FF,
+			opts.Reader,
+			opts.Cache,
+			baserules.WithSendAlways(),
+			baserules.WithSendUnmatched(),
+		)
+		if err != nil {
+			zap.L().Error("failed to prepare a new anomaly rule for test", zap.String("name", rule.Name()), zap.Error(err))
+			return 0, basemodel.BadRequest(err)
+		}
+	} else {
+		return 0, basemodel.BadRequest(fmt.Errorf("failed to derive ruletype with given information"))
+	}
+
+	// set timestamp to current utc time
+	ts := time.Now().UTC()
+
+	count, err := rule.Eval(ctx, ts)
+	if err != nil {
+		zap.L().Error("evaluating rule failed", zap.String("rule", rule.Name()), zap.Error(err))
+		return 0, basemodel.InternalError(fmt.Errorf("rule evaluation failed"))
+	}
+	alertsFound, ok := count.(int)
+	if !ok {
+		return 0, basemodel.InternalError(fmt.Errorf("something went wrong"))
+	}
+	rule.SendAlerts(ctx, ts, 0, time.Duration(1*time.Minute), opts.NotifyFunc)
+
+	return alertsFound, nil
+}
+
 // newTask returns an appropriate group for
 // rule type
 func newTask(taskType baserules.TaskType, name string, frequency time.Duration, rules []baserules.Rule, opts *baserules.ManagerOptions, notify baserules.NotifyFunc, ruleDB baserules.RuleDB) baserules.Task {

frontend/package.json

@@ -34,7 +34,7 @@
 		"@dnd-kit/core": "6.1.0",
 		"@dnd-kit/modifiers": "7.0.0",
 		"@dnd-kit/sortable": "8.0.0",
-		"@grafana/data": "^9.5.2",
+		"@grafana/data": "^11.2.3",
 		"@mdx-js/loader": "2.3.0",
 		"@mdx-js/react": "2.3.0",
 		"@monaco-editor/react": "^4.3.1",
@@ -42,7 +42,7 @@
 		"@radix-ui/react-tooltip": "1.0.7",
 		"@sentry/react": "7.102.1",
 		"@sentry/webpack-plugin": "2.16.0",
-		"@signozhq/design-tokens": "0.0.8",
+		"@signozhq/design-tokens": "1.1.4",
 		"@uiw/react-md-editor": "3.23.5",
 		"@visx/group": "3.3.0",
 		"@visx/shape": "3.5.0",
@@ -51,7 +51,7 @@
 		"ansi-to-html": "0.7.2",
 		"antd": "5.11.0",
 		"antd-table-saveas-excel": "2.2.1",
-		"axios": "1.7.4",
+		"axios": "1.7.7",
 		"babel-eslint": "^10.1.0",
 		"babel-jest": "^29.6.4",
 		"babel-loader": "9.1.3",
@@ -76,7 +76,7 @@
 		"fontfaceobserver": "2.3.0",
 		"history": "4.10.1",
 		"html-webpack-plugin": "5.5.0",
-		"http-proxy-middleware": "2.0.6",
+		"http-proxy-middleware": "2.0.7",
 		"i18next": "^21.6.12",
 		"i18next-browser-languagedetector": "^6.1.3",
 		"i18next-http-backend": "^1.3.2",
@@ -87,6 +87,8 @@
 		"lodash-es": "^4.17.21",
 		"lucide-react": "0.379.0",
 		"mini-css-extract-plugin": "2.4.5",
+		"overlayscrollbars": "^2.8.1",
+		"overlayscrollbars-react": "^0.5.6",
 		"papaparse": "5.4.1",
 		"posthog-js": "1.160.3",
 		"rc-tween-one": "3.0.6",
@@ -107,11 +109,10 @@
 		"react-query": "3.39.3",
 		"react-redux": "^7.2.2",
 		"react-router-dom": "^5.2.0",
+		"react-router-dom-v5-compat": "6.27.0",
 		"react-syntax-highlighter": "15.5.0",
 		"react-use": "^17.3.2",
 		"react-virtuoso": "4.0.3",
-		"overlayscrollbars-react": "^0.5.6",
-		"overlayscrollbars": "^2.8.1",
 		"redux": "^4.0.5",
 		"redux-thunk": "^2.3.0",
 		"rehype-raw": "7.0.0",
@@ -123,10 +124,10 @@
 		"ts-node": "^10.2.1",
 		"tsconfig-paths-webpack-plugin": "^3.5.1",
 		"typescript": "^4.0.5",
-		"uplot": "1.6.26",
+		"uplot": "1.6.31",
 		"uuid": "^8.3.2",
 		"web-vitals": "^0.2.4",
-		"webpack": "5.88.2",
+		"webpack": "5.94.0",
 		"webpack-dev-server": "^4.15.1",
 		"webpack-retry-chunk-load-plugin": "3.1.1",
 		"xstate": "^4.31.0"

frontend/public/locales/en-GB/messagingQueues.json

@@ -0,0 +1,24 @@
+{
+	"metricGraphCategory": {
+		"brokerMetrics": {
+			"title": "Broker Metrics",
+			"description": "The Kafka Broker metrics here inform you of data loss/delay through unclean leader elections and network throughputs, as well as request fails through request purgatories and timeouts metrics"
+		},
+		"consumerMetrics": {
+			"title": "Consumer Metrics",
+			"description": "Kafka Consumer metrics provide insights into lag between message production and consumption, success rates and latency of message delivery, and the volume of data consumed."
+		},
+		"producerMetrics": {
+			"title": "Producer Metrics",
+			"description": "Kafka Producers send messages to brokers for storage and distribution by topic. These metrics inform you of the volume and rate of data sent, and the success rate of message delivery."
+		},
+		"brokerJVMMetrics": {
+			"title": "Broker JVM Metrics",
+			"description": "Kafka brokers are Java applications that expose JVM metrics to inform on the broker's system health. Garbage collection metrics like those below provide key insights into free memory, broker performance, and heap size. You need to enable new_gc_metrics for this section to populate."
+		},
+		"partitionMetrics": {
+			"title": "Partition Metrics",
+			"description": "Kafka partitions are the unit of parallelism in Kafka. These metrics inform you of the number of partitions per topic, the current offset of each partition, the oldest offset, and the number of in-sync replicas."
+		}
+	}
+}

frontend/public/locales/en-GB/messagingQueuesKafkaOverview.json

@@ -1,30 +1,54 @@
 {
-  "breadcrumb": "Messaging Queues",
-  "header": "Kafka / Overview",
-  "overview": {
-    "title": "Start sending data in as little as 20 minutes",
-    "subtitle": "Connect and Monitor Your Data Streams"
-  },
-  "configureConsumer": {
-    "title": "Configure Consumer",
-    "description": "Add consumer data sources to gain insights and enhance monitoring.",
-    "button": "Get Started"
-  },
-  "configureProducer": {
-    "title": "Configure Producer",
-    "description": "Add producer data sources to gain insights and enhance monitoring.",
-    "button": "Get Started"
-  },
-  "monitorKafka": {
-    "title": "Monitor kafka",
-    "description": "Add your Kafka source to gain insights and enhance activity tracking.",
-    "button": "Get Started"
-  },
-  "summarySection": {
-    "viewDetailsButton": "View Details"
-  },
-  "confirmModal": {
-    "content": "Before navigating to the details page, please make sure you have configured all the required setup to ensure correct data monitoring.",
-    "okText": "Proceed"
-  }
-}
+	"breadcrumb": "Messaging Queues",
+	"header": "Kafka / Overview",
+	"overview": {
+		"title": "Start sending data in as little as 20 minutes",
+		"subtitle": "Connect and Monitor Your Data Streams"
+	},
+	"configureConsumer": {
+		"title": "Configure Consumer",
+		"description": "Add consumer data sources to gain insights and enhance monitoring.",
+		"button": "Get Started"
+	},
+	"configureProducer": {
+		"title": "Configure Producer",
+		"description": "Add producer data sources to gain insights and enhance monitoring.",
+		"button": "Get Started"
+	},
+	"monitorKafka": {
+		"title": "Monitor kafka",
+		"description": "Add your Kafka source to gain insights and enhance activity tracking.",
+		"button": "Get Started"
+	},
+	"summarySection": {
+		"viewDetailsButton": "View Details",
+		"consumer": {
+			"title": "Consumer lag view",
+			"description": "Connect and Monitor Your Data Streams"
+		},
+		"producer": {
+			"title": "Producer latency view",
+			"description": "Connect and Monitor Your Data Streams"
+		},
+		"partition": {
+			"title": "Partition Latency view",
+			"description": "Connect and Monitor Your Data Streams"
+		},
+		"dropRate": {
+			"title": "Drop Rate view",
+			"description": "Connect and Monitor Your Data Streams"
+		},
+		"metricPage": {
+			"title": "Metric View",
+			"description": "Connect and Monitor Your Data Streams"
+		}
+	},
+	"confirmModal": {
+		"content": "Before navigating to the details page, please make sure you have configured all the required setup to ensure correct data monitoring.",
+		"okText": "Proceed"
+	},
+	"overviewSummarySection": {
+		"title": "Monitor Your Data Streams",
+		"subtitle": "Monitor key Kafka metrics like consumer lag and latency to ensure efficient data flow and troubleshoot in real time."
+	}
+}

frontend/public/locales/en/messagingQueues.json

@@ -0,0 +1,24 @@
+{
+	"metricGraphCategory": {
+		"brokerMetrics": {
+			"title": "Broker Metrics",
+			"description": "The Kafka Broker metrics here inform you of data loss/delay through unclean leader elections and network throughputs, as well as request fails through request purgatories and timeouts metrics"
+		},
+		"consumerMetrics": {
+			"title": "Consumer Metrics",
+			"description": "Kafka Consumer metrics provide insights into lag between message production and consumption, success rates and latency of message delivery, and the volume of data consumed."
+		},
+		"producerMetrics": {
+			"title": "Producer Metrics",
+			"description": "Kafka Producers send messages to brokers for storage and distribution by topic. These metrics inform you of the volume and rate of data sent, and the success rate of message delivery."
+		},
+		"brokerJVMMetrics": {
+			"title": "Broker JVM Metrics",
+			"description": "Kafka brokers are Java applications that expose JVM metrics to inform on the broker's system health. Garbage collection metrics like those below provide key insights into free memory, broker performance, and heap size. You need to enable new_gc_metrics for this section to populate."
+		},
+		"partitionMetrics": {
+			"title": "Partition Metrics",
+			"description": "Kafka partitions are the unit of parallelism in Kafka. These metrics inform you of the number of partitions per topic, the current offset of each partition, the oldest offset, and the number of in-sync replicas."
+		}
+	}
+}

frontend/public/locales/en/messagingQueuesKafkaOverview.json

@@ -1,30 +1,54 @@
 {
-  "breadcrumb": "Messaging Queues",
-  "header": "Kafka / Overview",
-  "overview": {
-    "title": "Start sending data in as little as 20 minutes",
-    "subtitle": "Connect and Monitor Your Data Streams"
-  },
-  "configureConsumer": {
-    "title": "Configure Consumer",
-    "description": "Add consumer data sources to gain insights and enhance monitoring.",
-    "button": "Get Started"
-  },
-  "configureProducer": {
-    "title": "Configure Producer",
-    "description": "Add producer data sources to gain insights and enhance monitoring.",
-    "button": "Get Started"
-  },
-  "monitorKafka": {
-    "title": "Monitor kafka",
-    "description": "Add your Kafka source to gain insights and enhance activity tracking.",
-    "button": "Get Started"
-  },
-  "summarySection": {
-    "viewDetailsButton": "View Details"
-  },
-  "confirmModal": {
-    "content": "Before navigating to the details page, please make sure you have configured all the required setup to ensure correct data monitoring.",
-    "okText": "Proceed"
-  }
-}
+	"breadcrumb": "Messaging Queues",
+	"header": "Kafka / Overview",
+	"overview": {
+		"title": "Start sending data in as little as 20 minutes",
+		"subtitle": "Connect and Monitor Your Data Streams"
+	},
+	"configureConsumer": {
+		"title": "Configure Consumer",
+		"description": "Add consumer data sources to gain insights and enhance monitoring.",
+		"button": "Get Started"
+	},
+	"configureProducer": {
+		"title": "Configure Producer",
+		"description": "Add producer data sources to gain insights and enhance monitoring.",
+		"button": "Get Started"
+	},
+	"monitorKafka": {
+		"title": "Monitor kafka",
+		"description": "Add your Kafka source to gain insights and enhance activity tracking.",
+		"button": "Get Started"
+	},
+	"summarySection": {
+		"viewDetailsButton": "View Details",
+		"consumer": {
+			"title": "Consumer lag view",
+			"description": "Connect and Monitor Your Data Streams"
+		},
+		"producer": {
+			"title": "Producer latency view",
+			"description": "Connect and Monitor Your Data Streams"
+		},
+		"partition": {
+			"title": "Partition Latency view",
+			"description": "Connect and Monitor Your Data Streams"
+		},
+		"dropRate": {
+			"title": "Drop Rate view",
+			"description": "Connect and Monitor Your Data Streams"
+		},
+		"metricPage": {
+			"title": "Metric View",
+			"description": "Connect and Monitor Your Data Streams"
+		}
+	},
+	"confirmModal": {
+		"content": "Before navigating to the details page, please make sure you have configured all the required setup to ensure correct data monitoring.",
+		"okText": "Proceed"
+	},
+	"overviewSummarySection": {
+		"title": "Monitor Your Data Streams",
+		"subtitle": "Monitor key Kafka metrics like consumer lag and latency to ensure efficient data flow and troubleshoot in real time."
+	}
+}

frontend/public/locales/en/titles.json

@@ -4,6 +4,7 @@
 	"SERVICE_METRICS": "SigNoz | Service Metrics",
 	"SERVICE_MAP": "SigNoz | Service Map",
 	"GET_STARTED": "SigNoz | Get Started",
+	"ONBOARDING": "SigNoz | Get Started",
 	"GET_STARTED_APPLICATION_MONITORING": "SigNoz | Get Started | APM",
 	"GET_STARTED_LOGS_MANAGEMENT": "SigNoz | Get Started | Logs",
 	"GET_STARTED_INFRASTRUCTURE_MONITORING": "SigNoz | Get Started | Infrastructure",

frontend/src/AppRoutes/Private.tsx

@@ -1,5 +1,6 @@
 /* eslint-disable react-hooks/exhaustive-deps */
 import getLocalStorageApi from 'api/browser/localstorage/get';
+import getOrgUser from 'api/user/getOrgUser';
 import loginApi from 'api/user/login';
 import { Logout } from 'api/utils';
 import Spinner from 'components/Spinner';
@@ -8,8 +9,10 @@ import ROUTES from 'constants/routes';
 import useLicense from 'hooks/useLicense';
 import { useNotifications } from 'hooks/useNotifications';
 import history from 'lib/history';
-import { ReactChild, useEffect, useMemo } from 'react';
+import { isEmpty, isNull } from 'lodash-es';
+import { ReactChild, useEffect, useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
+import { useQuery } from 'react-query';
 import { useDispatch, useSelector } from 'react-redux';
 import { matchPath, Redirect, useLocation } from 'react-router-dom';
 import { Dispatch } from 'redux';
@@ -17,7 +20,9 @@ import { AppState } from 'store/reducers';
 import { getInitialUserTokenRefreshToken } from 'store/utils';
 import AppActions from 'types/actions';
 import { UPDATE_USER_IS_FETCH } from 'types/actions/app';
+import { Organization } from 'types/api/user/getOrganization';
 import AppReducer from 'types/reducer/app';
+import { isCloudUser } from 'utils/app';
 import { routePermission } from 'utils/permission';
 
 import routes, {
@@ -31,6 +36,19 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 	const location = useLocation();
 	const { pathname } = location;
 
+	const [isLoading, setIsLoading] = useState<boolean>(true);
+
+	const {
+		org,
+		orgPreferences,
+		user,
+		role,
+		isUserFetching,
+		isUserFetchingError,
+		isLoggedIn: isLoggedInState,
+		isFetchingOrgPreferences,
+	} = useSelector<AppState, AppReducer>((state) => state.app);
+
 	const mapRoutes = useMemo(
 		() =>
 			new Map(
@@ -44,18 +62,23 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 		[pathname],
 	);
 
+	const isOnboardingComplete = useMemo(
+		() =>
+			orgPreferences?.find(
+				(preference: Record<string, any>) => preference.key === 'ORG_ONBOARDING',
+			)?.value,
+		[orgPreferences],
+	);
+
 	const {
 		data: licensesData,
 		isFetching: isFetchingLicensesData,
 	} = useLicense();
 
-	const {
-		isUserFetching,
-		isUserFetchingError,
-		isLoggedIn: isLoggedInState,
-	} = useSelector<AppState, AppReducer>((state) => state.app);
-
 	const { t } = useTranslation(['common']);
+
+	const isCloudUserVal = isCloudUser();
+
 	const localStorageUserAuthToken = getInitialUserTokenRefreshToken();
 
 	const dispatch = useDispatch<Dispatch<AppActions>>();
@@ -66,6 +89,8 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 
 	const isOldRoute = oldRoutes.indexOf(pathname) > -1;
 
+	const [orgData, setOrgData] = useState<Organization | undefined>(undefined);
+
 	const isLocalStorageLoggedIn =
 		getLocalStorageApi(LOCALSTORAGE.IS_LOGGED_IN) === 'true';
 
@@ -81,6 +106,68 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 		}
 	};
 
+	const { data: orgUsers, isLoading: isLoadingOrgUsers } = useQuery({
+		queryFn: () => {
+			if (orgData && orgData.id !== undefined) {
+				return getOrgUser({
+					orgId: orgData.id,
+				});
+			}
+			return undefined;
+		},
+		queryKey: ['getOrgUser'],
+		enabled: !isEmpty(orgData),
+	});
+
+	const checkFirstTimeUser = (): boolean => {
+		const users = orgUsers?.payload || [];
+
+		const remainingUsers = users.filter(
+			(user) => user.email !== 'admin@signoz.cloud',
+		);
+
+		return remainingUsers.length === 1;
+	};
+
+	// Check if the onboarding should be shown based on the org users and onboarding completion status, wait for org users and preferences to load
+	const shouldShowOnboarding = (): boolean => {
+		// Only run this effect if the org users and preferences are loaded
+
+		if (!isLoadingOrgUsers && !isFetchingOrgPreferences) {
+			const isFirstUser = checkFirstTimeUser();
+
+			// Redirect to get started if it's not the first user or if the onboarding is complete
+			return isFirstUser && !isOnboardingComplete;
+		}
+
+		return false;
+	};
+
+	const handleRedirectForOrgOnboarding = (key: string): void => {
+		if (
+			isLoggedInState &&
+			isCloudUserVal &&
+			!isFetchingOrgPreferences &&
+			!isLoadingOrgUsers &&
+			!isEmpty(orgUsers?.payload) &&
+			!isNull(orgPreferences)
+		) {
+			if (key === 'ONBOARDING' && isOnboardingComplete) {
+				history.push(ROUTES.APPLICATION);
+			}
+
+			const isFirstTimeUser = checkFirstTimeUser();
+
+			if (isFirstTimeUser && !isOnboardingComplete) {
+				history.push(ROUTES.ONBOARDING);
+			}
+		}
+
+		if (!isCloudUserVal && key === 'ONBOARDING') {
+			history.push(ROUTES.APPLICATION);
+		}
+	};
+
 	const handleUserLoginIfTokenPresent = async (
 		key: keyof typeof ROUTES,
 	): Promise<void> => {
@@ -102,6 +189,8 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 					response.payload.refreshJwt,
 				);
 
+				handleRedirectForOrgOnboarding(key);
+
 				if (
 					userResponse &&
 					route &&
@@ -129,7 +218,7 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 		) {
 			handleUserLoginIfTokenPresent(key);
 		} else {
-			// user does have localstorage values
+			handleRedirectForOrgOnboarding(key);
 
 			navigateToLoginIfNotLoggedIn(isLocalStorageLoggedIn);
 		}
@@ -160,6 +249,45 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 		}
 	}, [isFetchingLicensesData]);
 
+	useEffect(() => {
+		if (org && org.length > 0 && org[0].id !== undefined) {
+			setOrgData(org[0]);
+		}
+	}, [org]);
+
+	const handleRouting = (): void => {
+		const showOrgOnboarding = shouldShowOnboarding();
+
+		if (showOrgOnboarding && !isOnboardingComplete && isCloudUserVal) {
+			history.push(ROUTES.ONBOARDING);
+		} else {
+			history.push(ROUTES.APPLICATION);
+		}
+	};
+
+	useEffect(() => {
+		const { isPrivate } = currentRoute || {
+			isPrivate: false,
+		};
+
+		if (isLoggedInState && role && role !== 'ADMIN') {
+			setIsLoading(false);
+		}
+
+		if (!isPrivate) {
+			setIsLoading(false);
+		}
+
+		if (
+			!isEmpty(user) &&
+			!isFetchingOrgPreferences &&
+			!isEmpty(orgUsers?.payload) &&
+			!isNull(orgPreferences)
+		) {
+			setIsLoading(false);
+		}
+	}, [currentRoute, user, role, orgUsers, orgPreferences]);
+
 	// eslint-disable-next-line sonarjs/cognitive-complexity
 	useEffect(() => {
 		(async (): Promise<void> => {
@@ -181,9 +309,8 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 						handlePrivateRoutes(key);
 					} else {
 						// no need to fetch the user and make user fetching false
-
 						if (getLocalStorageApi(LOCALSTORAGE.IS_LOGGED_IN) === 'true') {
-							history.push(ROUTES.APPLICATION);
+							handleRouting();
 						}
 						dispatch({
 							type: UPDATE_USER_IS_FETCH,
@@ -195,7 +322,7 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 				} else if (pathname === ROUTES.HOME_PAGE) {
 					// routing to application page over root page
 					if (isLoggedInState) {
-						history.push(ROUTES.APPLICATION);
+						handleRouting();
 					} else {
 						navigateToLoginIfNotLoggedIn();
 					}
@@ -208,13 +335,20 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 				history.push(ROUTES.SOMETHING_WENT_WRONG);
 			}
 		})();
-	}, [dispatch, isLoggedInState, currentRoute, licensesData]);
+	}, [
+		dispatch,
+		isLoggedInState,
+		currentRoute,
+		licensesData,
+		orgUsers,
+		orgPreferences,
+	]);
 
 	if (isUserFetchingError) {
 		return <Redirect to={ROUTES.SOMETHING_WENT_WRONG} />;
 	}
 
-	if (isUserFetching) {
+	if (isUserFetching || isLoading) {
 		return <Spinner tip="Loading..." />;
 	}
 

frontend/src/AppRoutes/index.tsx

@@ -2,6 +2,7 @@ import { ConfigProvider } from 'antd';
 import getLocalStorageApi from 'api/browser/localstorage/get';
 import setLocalStorageApi from 'api/browser/localstorage/set';
 import logEvent from 'api/common/logEvent';
+import getAllOrgPreferences from 'api/preferences/getAllOrgPreferences';
 import NotFound from 'components/NotFound';
 import Spinner from 'components/Spinner';
 import { FeatureKeys } from 'constants/features';
@@ -24,13 +25,20 @@ import AlertRuleProvider from 'providers/Alert';
 import { DashboardProvider } from 'providers/Dashboard/Dashboard';
 import { QueryBuilderProvider } from 'providers/QueryBuilder';
 import { Suspense, useEffect, useState } from 'react';
+import { useQuery } from 'react-query';
 import { useDispatch, useSelector } from 'react-redux';
 import { Route, Router, Switch } from 'react-router-dom';
+import { CompatRouter } from 'react-router-dom-v5-compat';
 import { Dispatch } from 'redux';
 import { AppState } from 'store/reducers';
 import AppActions from 'types/actions';
-import { UPDATE_FEATURE_FLAG_RESPONSE } from 'types/actions/app';
+import {
+	UPDATE_FEATURE_FLAG_RESPONSE,
+	UPDATE_IS_FETCHING_ORG_PREFERENCES,
+	UPDATE_ORG_PREFERENCES,
+} from 'types/actions/app';
 import AppReducer, { User } from 'types/reducer/app';
+import { USER_ROLES } from 'types/roles';
 import { extractDomain, isCloudUser, isEECloudUser } from 'utils/app';
 
 import PrivateRoute from './Private';
@@ -65,6 +73,41 @@ function App(): JSX.Element {
 	const isPremiumSupportEnabled =
 		useFeatureFlags(FeatureKeys.PREMIUM_SUPPORT)?.active || false;
 
+	const { data: orgPreferences, isLoading: isLoadingOrgPreferences } = useQuery({
+		queryFn: () => getAllOrgPreferences(),
+		queryKey: ['getOrgPreferences'],
+		enabled: isLoggedInState && role === USER_ROLES.ADMIN,
+	});
+
+	useEffect(() => {
+		if (orgPreferences && !isLoadingOrgPreferences) {
+			dispatch({
+				type: UPDATE_IS_FETCHING_ORG_PREFERENCES,
+				payload: {
+					isFetchingOrgPreferences: false,
+				},
+			});
+
+			dispatch({
+				type: UPDATE_ORG_PREFERENCES,
+				payload: {
+					orgPreferences: orgPreferences.payload?.data || null,
+				},
+			});
+		}
+	}, [orgPreferences, dispatch, isLoadingOrgPreferences]);
+
+	useEffect(() => {
+		if (isLoggedInState && role !== USER_ROLES.ADMIN) {
+			dispatch({
+				type: UPDATE_IS_FETCHING_ORG_PREFERENCES,
+				payload: {
+					isFetchingOrgPreferences: false,
+				},
+			});
+		}
+	}, [isLoggedInState, role, dispatch]);
+
 	const featureResponse = useGetFeatureFlag((allFlags) => {
 		dispatch({
 			type: UPDATE_FEATURE_FLAG_RESPONSE,
@@ -182,6 +225,16 @@ function App(): JSX.Element {
 	}, [isLoggedInState, isOnBasicPlan, user]);
 
 	useEffect(() => {
+		if (pathname === ROUTES.ONBOARDING) {
+			window.Intercom('update', {
+				hide_default_launcher: true,
+			});
+		} else {
+			window.Intercom('update', {
+				hide_default_launcher: false,
+			});
+		}
+
 		trackPageView(pathname);
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [pathname]);
@@ -204,6 +257,7 @@ function App(): JSX.Element {
 		user,
 		licenseData,
 		isPremiumSupportEnabled,
+		pathname,
 	]);
 
 	useEffect(() => {
@@ -239,36 +293,38 @@ function App(): JSX.Element {
 	return (
 		<ConfigProvider theme={themeConfig}>
 			<Router history={history}>
-				<NotificationProvider>
-					<PrivateRoute>
-						<ResourceProvider>
-							<QueryBuilderProvider>
-								<DashboardProvider>
-									<KeyboardHotkeysProvider>
-										<AlertRuleProvider>
-											<AppLayout>
-												<Suspense fallback={<Spinner size="large" tip="Loading..." />}>
-													<Switch>
-														{routes.map(({ path, component, exact }) => (
-															<Route
-																key={`${path}`}
-																exact={exact}
-																path={path}
-																component={component}
-															/>
-														))}
+				<CompatRouter>
+					<NotificationProvider>
+						<PrivateRoute>
+							<ResourceProvider>
+								<QueryBuilderProvider>
+									<DashboardProvider>
+										<KeyboardHotkeysProvider>
+											<AlertRuleProvider>
+												<AppLayout>
+													<Suspense fallback={<Spinner size="large" tip="Loading..." />}>
+														<Switch>
+															{routes.map(({ path, component, exact }) => (
+																<Route
+																	key={`${path}`}
+																	exact={exact}
+																	path={path}
+																	component={component}
+																/>
+															))}
 
-														<Route path="*" component={NotFound} />
-													</Switch>
-												</Suspense>
-											</AppLayout>
-										</AlertRuleProvider>
-									</KeyboardHotkeysProvider>
-								</DashboardProvider>
-							</QueryBuilderProvider>
-						</ResourceProvider>
-					</PrivateRoute>
-				</NotificationProvider>
+															<Route path="*" component={NotFound} />
+														</Switch>
+													</Suspense>
+												</AppLayout>
+											</AlertRuleProvider>
+										</KeyboardHotkeysProvider>
+									</DashboardProvider>
+								</QueryBuilderProvider>
+							</ResourceProvider>
+						</PrivateRoute>
+					</NotificationProvider>
+				</CompatRouter>
 			</Router>
 		</ConfigProvider>
 	);

frontend/src/AppRoutes/pageComponents.ts

@@ -66,6 +66,10 @@ export const Onboarding = Loadable(
 	() => import(/* webpackChunkName: "Onboarding" */ 'pages/OnboardingPage'),
 );
 
+export const OrgOnboarding = Loadable(
+	() => import(/* webpackChunkName: "OrgOnboarding" */ 'pages/OrgOnboarding'),
+);
+
 export const DashboardPage = Loadable(
 	() =>
 		import(/* webpackChunkName: "DashboardPage" */ 'pages/DashboardsListPage'),

frontend/src/AppRoutes/routes.ts

@@ -32,6 +32,7 @@ import {
 	OldLogsExplorer,
 	Onboarding,
 	OrganizationSettings,
+	OrgOnboarding,
 	PasswordReset,
 	PipelinePage,
 	ServiceMapPage,
@@ -68,6 +69,13 @@ const routes: AppRoutes[] = [
 		isPrivate: true,
 		key: 'GET_STARTED',
 	},
+	{
+		path: ROUTES.ONBOARDING,
+		exact: false,
+		component: OrgOnboarding,
+		isPrivate: true,
+		key: 'ONBOARDING',
+	},
 	{
 		component: LogsIndexToFields,
 		path: ROUTES.LOGS_INDEX_FIELDS,

frontend/src/api/alerts/create.ts

@@ -7,7 +7,6 @@ const create = async (
 ): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
 	const response = await axios.post('/rules', {
 		...props.data,
-		version: 'v4',
 	});
 
 	return {

frontend/src/api/apiV1.ts

@@ -4,6 +4,7 @@ export const apiV2 = '/api/v2/';
 export const apiV3 = '/api/v3/';
 export const apiV4 = '/api/v4/';
 export const gatewayApiV1 = '/api/gateway/v1/';
+export const gatewayApiV2 = '/api/gateway/v2/';
 export const apiAlertManager = '/api/alertmanager/';
 
 export default apiV1;

frontend/src/api/index.ts

@@ -15,6 +15,7 @@ import apiV1, {
 	apiV3,
 	apiV4,
 	gatewayApiV1,
+	gatewayApiV2,
 } from './apiV1';
 import { Logout } from './utils';
 
@@ -169,6 +170,19 @@ GatewayApiV1Instance.interceptors.response.use(
 GatewayApiV1Instance.interceptors.request.use(interceptorsRequestResponse);
 //
 
+// gateway Api V2
+export const GatewayApiV2Instance = axios.create({
+	baseURL: `${ENVIRONMENT.baseURL}${gatewayApiV2}`,
+});
+
+GatewayApiV2Instance.interceptors.response.use(
+	interceptorsResponse,
+	interceptorRejected,
+);
+
+GatewayApiV2Instance.interceptors.request.use(interceptorsRequestResponse);
+//
+
 AxiosAlertManagerInstance.interceptors.response.use(
 	interceptorsResponse,
 	interceptorRejected,

frontend/src/api/messagingQueues/onboarding/getOnboardingStatus.ts

@@ -0,0 +1,39 @@
+import { ApiBaseInstance } from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import { SOMETHING_WENT_WRONG } from 'constants/api';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+
+export interface OnboardingStatusResponse {
+	status: string;
+	data: {
+		attribute?: string;
+		error_message?: string;
+		status?: string;
+	}[];
+}
+
+const getOnboardingStatus = async (props: {
+	start: number;
+	end: number;
+	endpointService?: string;
+}): Promise<SuccessResponse<OnboardingStatusResponse> | ErrorResponse> => {
+	const { endpointService, ...rest } = props;
+	try {
+		const response = await ApiBaseInstance.post(
+			`/messaging-queues/kafka/onboarding/${endpointService || 'consumers'}`,
+			rest,
+		);
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandler((error as AxiosError) || SOMETHING_WENT_WRONG);
+	}
+};
+
+export default getOnboardingStatus;

frontend/src/api/onboarding/updateProfile.ts

@@ -0,0 +1,20 @@
+import { GatewayApiV2Instance } from 'api';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { UpdateProfileProps } from 'types/api/onboarding/types';
+
+const updateProfile = async (
+	props: UpdateProfileProps,
+): Promise<SuccessResponse<UpdateProfileProps> | ErrorResponse> => {
+	const response = await GatewayApiV2Instance.put('/profiles/me', {
+		...props,
+	});
+
+	return {
+		statusCode: 200,
+		error: null,
+		message: response.data.status,
+		payload: response.data.data,
+	};
+};
+
+export default updateProfile;

frontend/src/api/preferences/updateOrgPreference.ts

@@ -10,9 +10,12 @@ const updateOrgPreference = async (
 ): Promise<
 	SuccessResponse<UpdateOrgPreferenceResponseProps> | ErrorResponse
 > => {
-	const response = await axios.put(`/org/preferences`, {
-		preference_value: preferencePayload.value,
-	});
+	const response = await axios.put(
+		`/org/preferences/${preferencePayload.preferenceID}`,
+		{
+			preference_value: preferencePayload.value,
+		},
+	);
 
 	return {
 		statusCode: 200,

frontend/src/api/user/inviteUsers.ts

@@ -0,0 +1,18 @@
+import axios from 'api';
+import { SuccessResponse } from 'types/api';
+import { InviteUsersResponse, UsersProps } from 'types/api/user/inviteUsers';
+
+const inviteUsers = async (
+	users: UsersProps,
+): Promise<SuccessResponse<InviteUsersResponse>> => {
+	const response = await axios.post(`/invite/bulk`, users);
+
+	return {
+		statusCode: 200,
+		error: null,
+		message: response.data.status,
+		payload: response.data,
+	};
+};
+
+export default inviteUsers;

frontend/src/components/Logs/LogStateIndicator/utils.test.ts

@@ -17,6 +17,7 @@ describe('getLogIndicatorType', () => {
 			body: 'Sample log Message',
 			resources_string: {},
 			attributesString: {},
+			scope_string: {},
 			attributes_string: {},
 			attributesInt: {},
 			attributesFloat: {},
@@ -40,6 +41,7 @@ describe('getLogIndicatorType', () => {
 			body: 'Sample log Message',
 			resources_string: {},
 			attributesString: {},
+			scope_string: {},
 			attributes_string: {},
 			attributesInt: {},
 			attributesFloat: {},
@@ -62,6 +64,7 @@ describe('getLogIndicatorType', () => {
 			body: 'Sample log Message',
 			resources_string: {},
 			attributesString: {},
+			scope_string: {},
 			attributes_string: {},
 			attributesInt: {},
 			attributesFloat: {},
@@ -83,6 +86,7 @@ describe('getLogIndicatorType', () => {
 			body: 'Sample log',
 			resources_string: {},
 			attributesString: {},
+			scope_string: {},
 			attributes_string: {
 				log_level: 'INFO' as never,
 			},
@@ -112,6 +116,7 @@ describe('getLogIndicatorTypeForTable', () => {
 			attributesString: {},
 			attributes_string: {},
 			attributesInt: {},
+			scope_string: {},
 			attributesFloat: {},
 			severity_text: 'WARN',
 		};
@@ -130,6 +135,7 @@ describe('getLogIndicatorTypeForTable', () => {
 			severity_number: 0,
 			body: 'Sample log message',
 			resources_string: {},
+			scope_string: {},
 			attributesString: {},
 			attributes_string: {},
 			attributesInt: {},
@@ -166,6 +172,7 @@ describe('logIndicatorBySeverityNumber', () => {
 				body: 'Sample log Message',
 				resources_string: {},
 				attributesString: {},
+				scope_string: {},
 				attributes_string: {},
 				attributesInt: {},
 				attributesFloat: {},

frontend/src/constants/query.ts

@@ -37,4 +37,8 @@ export enum QueryParams {
 	partition = 'partition',
 	selectedTimelineQuery = 'selectedTimelineQuery',
 	ruleType = 'ruleType',
+	configDetail = 'configDetail',
+	getStartedSource = 'getStartedSource',
+	getStartedSourceService = 'getStartedSourceService',
+	mqServiceView = 'mqServiceView',
 }

frontend/src/constants/reactQueryKeys.ts

@@ -18,4 +18,5 @@ export const REACT_QUERY_KEY = {
 	GET_ALL_ALLERTS: 'GET_ALL_ALLERTS',
 	REMOVE_ALERT_RULE: 'REMOVE_ALERT_RULE',
 	DUPLICATE_ALERT_RULE: 'DUPLICATE_ALERT_RULE',
+	UPDATE_ALERT_RULE: 'UPDATE_ALERT_RULE',
 };

frontend/src/constants/routes.ts

@@ -8,6 +8,7 @@ const ROUTES = {
 	TRACE_DETAIL: '/trace/:id',
 	TRACES_EXPLORER: '/traces-explorer',
 	GET_STARTED: '/get-started',
+	ONBOARDING: '/onboarding',
 	GET_STARTED_APPLICATION_MONITORING: '/get-started/application-monitoring',
 	GET_STARTED_LOGS_MANAGEMENT: '/get-started/logs-management',
 	GET_STARTED_INFRASTRUCTURE_MONITORING:

frontend/src/container/AppLayout/AppLayout.styles.scss

@@ -7,6 +7,8 @@
 		width: calc(100% - 64px);
 		z-index: 0;
 
+		margin: 0 auto;
+
 		.content-container {
 			position: relative;
 			margin: 0 1rem;

frontend/src/container/AppLayout/index.tsx

@@ -191,6 +191,7 @@ function AppLayout(props: AppLayoutProps): JSX.Element {
 	const pageTitle = t(routeKey);
 	const renderFullScreen =
 		pathname === ROUTES.GET_STARTED ||
+		pathname === ROUTES.ONBOARDING ||
 		pathname === ROUTES.GET_STARTED_APPLICATION_MONITORING ||
 		pathname === ROUTES.GET_STARTED_INFRASTRUCTURE_MONITORING ||
 		pathname === ROUTES.GET_STARTED_LOGS_MANAGEMENT ||

frontend/src/container/CreateAlertRule/defaults.ts

@@ -57,6 +57,7 @@ export const alertDefaults: AlertDef = {
 	},
 	annotations: defaultAnnotations,
 	evalWindow: defaultEvalWindow,
+	alert: '',
 };
 
 export const anamolyAlertDefaults: AlertDef = {
@@ -94,16 +95,19 @@ export const anamolyAlertDefaults: AlertDef = {
 		matchType: defaultMatchType,
 		algorithm: defaultAlgorithm,
 		seasonality: defaultSeasonality,
+		target: 3,
 	},
 	labels: {
 		severity: 'warning',
 	},
 	annotations: defaultAnnotations,
 	evalWindow: defaultEvalWindow,
+	alert: '',
 };
 
 export const logAlertDefaults: AlertDef = {
 	alertType: AlertTypes.LOGS_BASED_ALERT,
+	version: ENTITY_VERSION_V4,
 	condition: {
 		compositeQuery: {
 			builderQueries: {
@@ -130,10 +134,12 @@ export const logAlertDefaults: AlertDef = {
 	},
 	annotations: defaultAnnotations,
 	evalWindow: defaultEvalWindow,
+	alert: '',
 };
 
 export const traceAlertDefaults: AlertDef = {
 	alertType: AlertTypes.TRACES_BASED_ALERT,
+	version: ENTITY_VERSION_V4,
 	condition: {
 		compositeQuery: {
 			builderQueries: {
@@ -160,10 +166,12 @@ export const traceAlertDefaults: AlertDef = {
 	},
 	annotations: defaultAnnotations,
 	evalWindow: defaultEvalWindow,
+	alert: '',
 };
 
 export const exceptionAlertDefaults: AlertDef = {
 	alertType: AlertTypes.EXCEPTIONS_BASED_ALERT,
+	version: ENTITY_VERSION_V4,
 	condition: {
 		compositeQuery: {
 			builderQueries: {
@@ -190,6 +198,7 @@ export const exceptionAlertDefaults: AlertDef = {
 	},
 	annotations: defaultAnnotations,
 	evalWindow: defaultEvalWindow,
+	alert: '',
 };
 
 export const ALERTS_VALUES_MAP: Record<AlertTypes, AlertDef> = {

frontend/src/container/ExplorerOptions/utils.ts

@@ -1,4 +1,4 @@
-import { Color } from '@signozhq/design-tokens';
+import { Color, ColorType } from '@signozhq/design-tokens';
 import { showErrorNotification } from 'components/ExplorerCard/utils';
 import { LOCALSTORAGE } from 'constants/localStorage';
 import { QueryParams } from 'constants/query';
@@ -8,7 +8,7 @@ import { DataSource } from 'types/common/queryBuilder';
 
 import { SaveNewViewHandlerProps } from './types';
 
-export const getRandomColor = (): Color => {
+export const getRandomColor = (): ColorType => {
 	const colorKeys = Object.keys(Color) as (keyof typeof Color)[];
 	const randomKey = colorKeys[Math.floor(Math.random() * colorKeys.length)];
 	return Color[randomKey];

frontend/src/container/FormAlertRules/RuleOptions.tsx

@@ -386,32 +386,31 @@ function RuleOptions({
 					renderThresholdRuleOpts()}
 
 				<Space direction="vertical" size="large">
-					{queryCategory !== EQueryType.PROM &&
-						ruleType !== AlertDetectionTypes.ANOMALY_DETECTION_ALERT && (
-							<Space direction="horizontal" align="center">
-								<Form.Item noStyle name={['condition', 'target']}>
-									<InputNumber
-										addonBefore={t('field_threshold')}
-										value={alertDef?.condition?.target}
-										onChange={onChange}
-										type="number"
-										onWheel={(e): void => e.currentTarget.blur()}
-									/>
-								</Form.Item>
+					{ruleType !== AlertDetectionTypes.ANOMALY_DETECTION_ALERT && (
+						<Space direction="horizontal" align="center">
+							<Form.Item noStyle name={['condition', 'target']}>
+								<InputNumber
+									addonBefore={t('field_threshold')}
+									value={alertDef?.condition?.target}
+									onChange={onChange}
+									type="number"
+									onWheel={(e): void => e.currentTarget.blur()}
+								/>
+							</Form.Item>
 
-								<Form.Item noStyle>
-									<Select
-										getPopupContainer={popupContainer}
-										allowClear
-										showSearch
-										options={categorySelectOptions}
-										placeholder={t('field_unit')}
-										value={alertDef.condition.targetUnit}
-										onChange={onChangeAlertUnit}
-									/>
-								</Form.Item>
-							</Space>
-						)}
+							<Form.Item noStyle>
+								<Select
+									getPopupContainer={popupContainer}
+									allowClear
+									showSearch
+									options={categorySelectOptions}
+									placeholder={t('field_unit')}
+									value={alertDef.condition.targetUnit}
+									onChange={onChangeAlertUnit}
+								/>
+							</Form.Item>
+						</Space>
+					)}
 
 					<Collapse>
 						<Collapse.Panel header={t('More options')} key="1">

frontend/src/container/FormAlertRules/index.tsx

@@ -53,6 +53,7 @@ import {
 	QueryFunctionProps,
 } from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
+import { DataSource } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
 
 import BasicInfo from './BasicInfo';
@@ -73,6 +74,19 @@ export enum AlertDetectionTypes {
 	ANOMALY_DETECTION_ALERT = 'anomaly_rule',
 }
 
+const ALERT_SETUP_GUIDE_URLS: Record<AlertTypes, string> = {
+	[AlertTypes.METRICS_BASED_ALERT]:
+		'https://signoz.io/docs/alerts-management/metrics-based-alerts/?utm_source=product&utm_medium=alert-creation-page',
+	[AlertTypes.LOGS_BASED_ALERT]:
+		'https://signoz.io/docs/alerts-management/log-based-alerts/?utm_source=product&utm_medium=alert-creation-page',
+	[AlertTypes.TRACES_BASED_ALERT]:
+		'https://signoz.io/docs/alerts-management/trace-based-alerts/?utm_source=product&utm_medium=alert-creation-page',
+	[AlertTypes.EXCEPTIONS_BASED_ALERT]:
+		'https://signoz.io/docs/alerts-management/exceptions-based-alerts/?utm_source=product&utm_medium=alert-creation-page',
+	[AlertTypes.ANOMALY_BASED_ALERT]:
+		'https://signoz.io/docs/alerts-management/anomaly-based-alerts/?utm_source=product&utm_medium=alert-creation-page',
+};
+
 // eslint-disable-next-line sonarjs/cognitive-complexity
 function FormAlertRules({
 	alertType,
@@ -92,6 +106,11 @@ function FormAlertRules({
 	const location = useLocation();
 	const queryParams = new URLSearchParams(location.search);
 
+	const dataSource = useMemo(
+		() => urlQuery.get(QueryParams.alertType) as DataSource,
+		[urlQuery],
+	);
+
 	// In case of alert the panel types should always be "Graph" only
 	const panelType = PANEL_TYPES.TIME_SERIES;
 
@@ -101,13 +120,12 @@ function FormAlertRules({
 		handleSetQueryData,
 		handleRunQuery,
 		handleSetConfig,
-		initialDataSource,
 		redirectWithQueryBuilderData,
 	} = useQueryBuilder();
 
 	useEffect(() => {
-		handleSetConfig(panelType || PANEL_TYPES.TIME_SERIES, initialDataSource);
-	}, [handleSetConfig, initialDataSource, panelType]);
+		handleSetConfig(panelType || PANEL_TYPES.TIME_SERIES, dataSource);
+	}, [handleSetConfig, dataSource, panelType]);
 
 	// use query client
 	const ruleCache = useQueryClient();
@@ -702,6 +720,29 @@ function FormAlertRules({
 
 	const isRuleCreated = !ruleId || ruleId === 0;
 
+	function handleRedirection(option: AlertTypes): void {
+		let url;
+		if (
+			option === AlertTypes.METRICS_BASED_ALERT &&
+			alertTypeFromURL === AlertDetectionTypes.ANOMALY_DETECTION_ALERT
+		) {
+			url = ALERT_SETUP_GUIDE_URLS[AlertTypes.ANOMALY_BASED_ALERT];
+		} else {
+			url = ALERT_SETUP_GUIDE_URLS[option];
+		}
+
+		if (url) {
+			logEvent('Alert: Check example alert clicked', {
+				dataSource: ALERTS_DATA_SOURCE_MAP[alertDef?.alertType as AlertTypes],
+				isNewRule: !ruleId || ruleId === 0,
+				ruleId,
+				queryType: currentQuery.queryType,
+				link: url,
+			});
+			window.open(url, '_blank');
+		}
+	}
+
 	useEffect(() => {
 		if (!isRuleCreated) {
 			logEvent('Alert: Edit page visited', {
@@ -752,7 +793,11 @@ function FormAlertRules({
 						)}
 					</div>
 
-					<Button className="periscope-btn" icon={<ExternalLink size={14} />}>
+					<Button
+						className="periscope-btn"
+						onClick={(): void => handleRedirection(alertDef.alertType as AlertTypes)}
+						icon={<ExternalLink size={14} />}
+					>
 						Alert Setup Guide
 					</Button>
 				</div>

frontend/src/container/FormAlertRules/labels/index.tsx

@@ -138,6 +138,9 @@ function LabelSelect({
 						if (e.key === 'Enter' || e.code === 'Enter' || e.key === ':') {
 							send('NEXT');
 						}
+						if (state.value === 'Idle') {
+							send('NEXT');
+						}
 					}}
 					bordered={false}
 					value={currentVal as never}

frontend/src/container/GridCardLayout/WidgetHeader/index.tsx

@@ -18,6 +18,7 @@ import { QueryParams } from 'constants/query';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import useCreateAlerts from 'hooks/queryBuilder/useCreateAlerts';
 import useComponentPermission from 'hooks/useComponentPermission';
+import useUrlQuery from 'hooks/useUrlQuery';
 import history from 'lib/history';
 import { RowData } from 'lib/query/createTableColumnsFromQuery';
 import { isEmpty } from 'lodash-es';
@@ -72,16 +73,18 @@ function WidgetHeader({
 	tableProcessedDataRef,
 	setSearchTerm,
 }: IWidgetHeaderProps): JSX.Element | null {
+	const urlQuery = useUrlQuery();
 	const onEditHandler = useCallback((): void => {
 		const widgetId = widget.id;
-		history.push(
-			`${window.location.pathname}/new?widgetId=${widgetId}&graphType=${
-				widget.panelTypes
-			}&${QueryParams.compositeQuery}=${encodeURIComponent(
-				JSON.stringify(widget.query),
-			)}`,
+		urlQuery.set(QueryParams.widgetId, widgetId);
+		urlQuery.set(QueryParams.graphType, widget.panelTypes);
+		urlQuery.set(
+			QueryParams.compositeQuery,
+			encodeURIComponent(JSON.stringify(widget.query)),
 		);
-	}, [widget.id, widget.panelTypes, widget.query]);
+		const generatedUrl = `${window.location.pathname}/new?${urlQuery}`;
+		history.push(generatedUrl);
+	}, [urlQuery, widget.id, widget.panelTypes, widget.query]);
 
 	const onCreateAlertsHandler = useCreateAlerts(widget, 'dashboardView');
 

frontend/src/container/IngestionSettings/IngestionSettings.styles.scss

@@ -18,8 +18,13 @@
 			font-style: normal;
 			font-weight: var(--font-weight-normal);
 			line-height: 28px;
-			/* 155.556% */
 			letter-spacing: -0.09px;
+
+			width: 72%; // arbitrary number to match input width
+			display: flex;
+			align-items: center;
+			gap: 8px;
+			justify-content: space-between;
 		}
 
 		.subtitle {
@@ -356,6 +361,8 @@
 						flex: 1;
 
 						.heading {
+							margin-bottom: 8px;
+
 							.title {
 								font-size: 12px;
 							}
@@ -370,6 +377,18 @@
 						.ant-input-number {
 							width: 80%;
 						}
+
+						.no-limit {
+							display: flex;
+							align-items: center;
+							gap: 8px;
+
+							margin-bottom: 24px;
+
+							font-weight: 700;
+							font-size: 12px;
+							color: var(--bg-forest-400);
+						}
 					}
 
 					.signal-limit-view-mode {

frontend/src/container/IngestionSettings/MultiIngestionSettings.tsx

@@ -12,6 +12,7 @@ import {
 	Modal,
 	Row,
 	Select,
+	Switch,
 	Table,
 	TablePaginationConfig,
 	TableProps as AntDTableProps,
@@ -34,7 +35,7 @@ import dayjs, { Dayjs } from 'dayjs';
 import { useGetAllIngestionsKeys } from 'hooks/IngestionKeys/useGetAllIngestionKeys';
 import useDebouncedFn from 'hooks/useDebouncedFunction';
 import { useNotifications } from 'hooks/useNotifications';
-import { isNil } from 'lodash-es';
+import { isNil, isUndefined } from 'lodash-es';
 import {
 	ArrowUpRight,
 	CalendarClock,
@@ -395,84 +396,6 @@ function MultiIngestionSettings(): JSX.Element {
 	const getFormattedTime = (date: string): string =>
 		dayjs(date).format('MMM DD,YYYY, hh:mm a');
 
-	const handleAddLimit = (
-		APIKey: IngestionKeyProps,
-		signalName: string,
-	): void => {
-		setActiveSignal({
-			id: signalName,
-			signal: signalName,
-			config: {},
-		});
-
-		const { dailyLimit, secondsLimit } = addEditLimitForm.getFieldsValue();
-
-		const payload = {
-			keyID: APIKey.id,
-			signal: signalName,
-			config: {
-				day: {
-					size: gbToBytes(dailyLimit),
-				},
-				second: {
-					size: gbToBytes(secondsLimit),
-				},
-			},
-		};
-
-		createLimitForIngestionKey(payload);
-	};
-
-	const handleUpdateLimit = (
-		APIKey: IngestionKeyProps,
-		signal: LimitProps,
-	): void => {
-		setActiveSignal(signal);
-		const { dailyLimit, secondsLimit } = addEditLimitForm.getFieldsValue();
-		const payload = {
-			limitID: signal.id,
-			signal: signal.signal,
-			config: {
-				day: {
-					size: gbToBytes(dailyLimit),
-				},
-				second: {
-					size: gbToBytes(secondsLimit),
-				},
-			},
-		};
-		updateLimitForIngestionKey(payload);
-	};
-
-	const bytesToGb = (size: number | undefined): number => {
-		if (!size) {
-			return 0;
-		}
-
-		return size / BYTES;
-	};
-
-	const enableEditLimitMode = (
-		APIKey: IngestionKeyProps,
-		signal: LimitProps,
-	): void => {
-		setActiveAPIKey(APIKey);
-		setActiveSignal(signal);
-
-		addEditLimitForm.setFieldsValue({
-			dailyLimit: bytesToGb(signal?.config?.day?.size || 0),
-			secondsLimit: bytesToGb(signal?.config?.second?.size || 0),
-		});
-
-		setIsEditAddLimitOpen(true);
-	};
-
-	const onDeleteLimitHandler = (): void => {
-		if (activeSignal && activeSignal?.id) {
-			deleteLimitForKey(activeSignal.id);
-		}
-	};
-
 	const showDeleteLimitModal = (
 		APIKey: IngestionKeyProps,
 		limit: LimitProps,
@@ -496,6 +419,131 @@ function MultiIngestionSettings(): JSX.Element {
 		addEditLimitForm.resetFields();
 	};
 
+	const handleAddLimit = (
+		APIKey: IngestionKeyProps,
+		signalName: string,
+	): void => {
+		const { dailyLimit, secondsLimit } = addEditLimitForm.getFieldsValue();
+
+		const payload = {
+			keyID: APIKey.id,
+			signal: signalName,
+			config: {},
+		};
+
+		if (!isUndefined(dailyLimit)) {
+			payload.config = {
+				day: {
+					size: gbToBytes(dailyLimit),
+				},
+			};
+		}
+
+		if (!isUndefined(secondsLimit)) {
+			payload.config = {
+				...payload.config,
+				second: {
+					size: gbToBytes(secondsLimit),
+				},
+			};
+		}
+
+		if (isUndefined(dailyLimit) && isUndefined(secondsLimit)) {
+			// No need to save as no limit is provided, close the edit view and reset active signal and api key
+			setActiveSignal(null);
+			setActiveAPIKey(null);
+			setIsEditAddLimitOpen(false);
+			setUpdatedTags([]);
+			hideAddViewModal();
+			setHasCreateLimitForIngestionKeyError(false);
+
+			return;
+		}
+
+		createLimitForIngestionKey(payload);
+	};
+
+	const handleUpdateLimit = (
+		APIKey: IngestionKeyProps,
+		signal: LimitProps,
+	): void => {
+		const { dailyLimit, secondsLimit } = addEditLimitForm.getFieldsValue();
+		const payload = {
+			limitID: signal.id,
+			signal: signal.signal,
+			config: {},
+		};
+
+		if (isUndefined(dailyLimit) && isUndefined(secondsLimit)) {
+			showDeleteLimitModal(APIKey, signal);
+
+			return;
+		}
+
+		if (!isUndefined(dailyLimit)) {
+			payload.config = {
+				day: {
+					size: gbToBytes(dailyLimit),
+				},
+			};
+		}
+
+		if (!isUndefined(secondsLimit)) {
+			payload.config = {
+				...payload.config,
+				second: {
+					size: gbToBytes(secondsLimit),
+				},
+			};
+		}
+
+		updateLimitForIngestionKey(payload);
+	};
+
+	const bytesToGb = (size: number | undefined): number => {
+		if (!size) {
+			return 0;
+		}
+
+		return size / BYTES;
+	};
+
+	const enableEditLimitMode = (
+		APIKey: IngestionKeyProps,
+		signal: LimitProps,
+	): void => {
+		setActiveAPIKey(APIKey);
+		setActiveSignal({
+			...signal,
+			config: {
+				...signal.config,
+				day: {
+					...signal.config?.day,
+					enabled: !isNil(signal?.config?.day?.size),
+				},
+				second: {
+					...signal.config?.second,
+					enabled: !isNil(signal?.config?.second?.size),
+				},
+			},
+		});
+
+		addEditLimitForm.setFieldsValue({
+			dailyLimit: bytesToGb(signal?.config?.day?.size || 0),
+			secondsLimit: bytesToGb(signal?.config?.second?.size || 0),
+			enableDailyLimit: !isNil(signal?.config?.day?.size),
+			enableSecondLimit: !isNil(signal?.config?.second?.size),
+		});
+
+		setIsEditAddLimitOpen(true);
+	};
+
+	const onDeleteLimitHandler = (): void => {
+		if (activeSignal && activeSignal?.id) {
+			deleteLimitForKey(activeSignal.id);
+		}
+	};
+
 	const columns: AntDTableProps<IngestionKeyProps>['columns'] = [
 		{
 			title: 'Ingestion Key',
@@ -684,50 +732,108 @@ function MultiIngestionSettings(): JSX.Element {
 																	<div className="signal-limit-edit-mode">
 																		<div className="daily-limit">
 																			<div className="heading">
-																				<div className="title"> Daily limit </div>
+																				<div className="title">
+																					Daily limit
+																					<div className="limit-enable-disable-toggle">
+																						<Form.Item name="enableDailyLimit">
+																							<Switch
+																								size="small"
+																								checked={activeSignal?.config?.day?.enabled}
+																								onChange={(value): void => {
+																									setActiveSignal({
+																										...activeSignal,
+																										config: {
+																											...activeSignal.config,
+																											day: {
+																												...activeSignal.config?.day,
+																												enabled: value,
+																											},
+																										},
+																									});
+																								}}
+																							/>
+																						</Form.Item>
+																					</div>
+																				</div>
 																				<div className="subtitle">
-																					Add a limit for data ingested daily{' '}
+																					Add a limit for data ingested daily
 																				</div>
 																			</div>
-
 																			<div className="size">
-																				<Form.Item name="dailyLimit">
-																					<InputNumber
-																						addonAfter={
-																							<Select defaultValue="GiB" disabled>
-																								<Option value="TiB"> TiB</Option>
-																								<Option value="GiB"> GiB</Option>
-																								<Option value="MiB"> MiB </Option>
-																								<Option value="KiB"> KiB </Option>
-																							</Select>
-																						}
-																					/>
-																				</Form.Item>
+																				{activeSignal?.config?.day?.enabled ? (
+																					<Form.Item name="dailyLimit" key="dailyLimit">
+																						<InputNumber
+																							disabled={!activeSignal?.config?.day?.enabled}
+																							key="dailyLimit"
+																							addonAfter={
+																								<Select defaultValue="GiB" disabled>
+																									<Option value="TiB"> TiB</Option>
+																									<Option value="GiB"> GiB</Option>
+																									<Option value="MiB"> MiB </Option>
+																									<Option value="KiB"> KiB </Option>
+																								</Select>
+																							}
+																						/>
+																					</Form.Item>
+																				) : (
+																					<div className="no-limit">
+																						<Infinity size={16} /> NO LIMIT
+																					</div>
+																				)}
 																			</div>
 																		</div>
 
 																		<div className="second-limit">
 																			<div className="heading">
-																				<div className="title"> Per Second limit </div>
+																				<div className="title">
+																					Per Second limit{' '}
+																					<div className="limit-enable-disable-toggle">
+																						<Form.Item name="enableSecondLimit">
+																							<Switch
+																								size="small"
+																								checked={activeSignal?.config?.second?.enabled}
+																								onChange={(value): void => {
+																									setActiveSignal({
+																										...activeSignal,
+																										config: {
+																											...activeSignal.config,
+																											second: {
+																												...activeSignal.config?.second,
+																												enabled: value,
+																											},
+																										},
+																									});
+																								}}
+																							/>
+																						</Form.Item>
+																					</div>
+																				</div>
 																				<div className="subtitle">
-																					{' '}
-																					Add a limit for data ingested every second{' '}
+																					Add a limit for data ingested every second
 																				</div>
 																			</div>
 
 																			<div className="size">
-																				<Form.Item name="secondsLimit">
-																					<InputNumber
-																						addonAfter={
-																							<Select defaultValue="GiB" disabled>
-																								<Option value="TiB"> TiB</Option>
-																								<Option value="GiB"> GiB</Option>
-																								<Option value="MiB"> MiB </Option>
-																								<Option value="KiB"> KiB </Option>
-																							</Select>
-																						}
-																					/>
-																				</Form.Item>
+																				{activeSignal?.config?.second?.enabled ? (
+																					<Form.Item name="secondsLimit" key="secondsLimit">
+																						<InputNumber
+																							key="secondsLimit"
+																							disabled={!activeSignal?.config?.second?.enabled}
+																							addonAfter={
+																								<Select defaultValue="GiB" disabled>
+																									<Option value="TiB"> TiB</Option>
+																									<Option value="GiB"> GiB</Option>
+																									<Option value="MiB"> MiB </Option>
+																									<Option value="KiB"> KiB </Option>
+																								</Select>
+																							}
+																						/>
+																					</Form.Item>
+																				) : (
+																					<div className="no-limit">
+																						<Infinity size={16} /> NO LIMIT
+																					</div>
+																				)}
 																			</div>
 																		</div>
 																	</div>

frontend/src/container/ListOfDashboard/DashboardList.styles.scss

@@ -5,6 +5,17 @@
 	justify-content: center;
 	width: 100%;
 
+	// overridding the request integration style to fix the spacing for dashboard list
+	.request-entity-container {
+		margin-bottom: 16px !important;
+		margin-top: 0 !important;
+	}
+
+	.integrations-content {
+		max-width: 100% !important;
+		width: 100% !important;
+	}
+
 	.dashboards-list-view-content {
 		width: calc(100% - 30px);
 		max-width: 836px;

frontend/src/container/ListOfDashboard/DashboardsList.tsx

@@ -77,6 +77,7 @@ import { isCloudUser } from 'utils/app';
 
 import DashboardTemplatesModal from './DashboardTemplates/DashboardTemplatesModal';
 import ImportJSON from './ImportJSON';
+import { RequestDashboardBtn } from './RequestDashboardBtn';
 import { DeleteButton } from './TableComponents/DeleteButton';
 import {
 	DashboardDynamicColumns,
@@ -692,6 +693,13 @@ function DashboardsList(): JSX.Element {
 							Create and manage dashboards for your workspace.
 						</Typography.Text>
 					</Flex>
+					{isCloudUser() && (
+						<div className="integrations-container">
+							<div className="integrations-content">
+								<RequestDashboardBtn />
+							</div>
+						</div>
+					)}
 				</div>
 
 				{isDashboardListLoading ||

frontend/src/container/ListOfDashboard/ImportJSON/index.tsx

@@ -82,9 +82,8 @@ function ImportJSON({
 
 			const dashboardData = JSON.parse(editorValue) as DashboardData;
 
-			// Add validation for uuid
-			if (dashboardData.uuid !== undefined && dashboardData.uuid.trim() === '') {
-				// silently remove uuid if it is empty
+			// Remove uuid from the dashboard data, in all cases - empty, duplicate or any valid not duplicate uuid
+			if (dashboardData.uuid !== undefined) {
 				delete dashboardData.uuid;
 			}
 

frontend/src/container/ListOfDashboard/RequestDashboardBtn.tsx

@@ -0,0 +1,95 @@
+import '../../pages/Integrations/Integrations.styles.scss';
+
+import { LoadingOutlined } from '@ant-design/icons';
+import { Button, Input, Space, Typography } from 'antd';
+import logEvent from 'api/common/logEvent';
+import { useNotifications } from 'hooks/useNotifications';
+import { Check } from 'lucide-react';
+import { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+
+export function RequestDashboardBtn(): JSX.Element {
+	const [
+		isSubmittingRequestForDashboard,
+		setIsSubmittingRequestForDashboard,
+	] = useState(false);
+
+	const [requestedDashboardName, setRequestedDashboardName] = useState('');
+
+	const { notifications } = useNotifications();
+	const { t } = useTranslation(['common']);
+
+	const handleRequestDashboardSubmit = async (): Promise<void> => {
+		try {
+			setIsSubmittingRequestForDashboard(true);
+			const response = await logEvent('Dashboard Requested', {
+				screen: 'Dashboard list page',
+				dashboard: requestedDashboardName,
+			});
+
+			if (response.statusCode === 200) {
+				notifications.success({
+					message: 'Dashboard Request Submitted',
+				});
+
+				setIsSubmittingRequestForDashboard(false);
+			} else {
+				notifications.error({
+					message:
+						response.error ||
+						t('something_went_wrong', {
+							ns: 'common',
+						}),
+				});
+
+				setIsSubmittingRequestForDashboard(false);
+			}
+		} catch (error) {
+			notifications.error({
+				message: t('something_went_wrong', {
+					ns: 'common',
+				}),
+			});
+
+			setIsSubmittingRequestForDashboard(false);
+		}
+	};
+
+	return (
+		<div className="request-entity-container">
+			<Typography.Text>
+				Can&apos;t find the dashboard you need? Request a new Dashboard.
+			</Typography.Text>
+
+			<div className="form-section">
+				<Space.Compact style={{ width: '100%' }}>
+					<Input
+						placeholder="Enter dashboard name..."
+						style={{ width: 300, marginBottom: 0 }}
+						value={requestedDashboardName}
+						onChange={(e): void => setRequestedDashboardName(e.target.value)}
+					/>
+					<Button
+						className="periscope-btn primary"
+						icon={
+							isSubmittingRequestForDashboard ? (
+								<LoadingOutlined />
+							) : (
+								<Check size={12} />
+							)
+						}
+						type="primary"
+						onClick={handleRequestDashboardSubmit}
+						disabled={
+							isSubmittingRequestForDashboard ||
+							!requestedDashboardName ||
+							requestedDashboardName?.trim().length === 0
+						}
+					>
+						Submit
+					</Button>
+				</Space.Compact>
+			</div>
+		</div>
+	);
+}

frontend/src/container/LogDetailedView/utils.tsx

@@ -157,6 +157,11 @@ export const getFieldAttributes = (field: string): IFieldAttributes => {
 		const stringWithoutPrefix = field.slice('resources_'.length);
 		const parts = splitOnce(stringWithoutPrefix, '.');
 		[dataType, newField] = parts;
+	} else if (field.startsWith('scope_string')) {
+		logType = MetricsType.Scope;
+		const stringWithoutPrefix = field.slice('scope_'.length);
+		const parts = splitOnce(stringWithoutPrefix, '.');
+		[dataType, newField] = parts;
 	}
 
 	return { dataType, newField, logType };
@@ -187,6 +192,7 @@ export const aggregateAttributesResourcesToString = (logData: ILog): string => {
 		traceId: logData.traceId,
 		attributes: {},
 		resources: {},
+		scope: {},
 		severity_text: logData.severity_text,
 		severity_number: logData.severity_number,
 	};
@@ -198,6 +204,9 @@ export const aggregateAttributesResourcesToString = (logData: ILog): string => {
 		} else if (key.startsWith('resources_')) {
 			outputJson.resources = outputJson.resources || {};
 			Object.assign(outputJson.resources, logData[key as keyof ILog]);
+		} else if (key.startsWith('scope_string')) {
+			outputJson.scope = outputJson.scope || {};
+			Object.assign(outputJson.scope, logData[key as keyof ILog]);
 		} else {
 			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
 			// @ts-ignore

frontend/src/container/LogsExplorerViews/index.tsx

@@ -202,6 +202,7 @@ function LogsExplorerViews({
 					id: 'severity_text--string----true',
 				},
 			],
+			legend: '{{severity_text}}',
 		};
 
 		const modifiedQuery: Query = {

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

@@ -58,12 +58,17 @@ export const databaseCallsRPS = ({
 	const legends = [legend];
 	const dataSource = DataSource.METRICS;
 
+	const timeAggregateOperators = [MetricAggregateOperator.RATE];
+	const spaceAggregateOperators = [MetricAggregateOperator.SUM];
+
 	return getQueryBuilderQueries({
 		autocompleteData,
 		groupBy,
 		legends,
 		filterItems,
 		dataSource,
+		timeAggregateOperators,
+		spaceAggregateOperators,
 	});
 };
 

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

@@ -213,12 +213,17 @@ export const externalCallRpsByAddress = ({
 	const legends = [legend];
 	const dataSource = DataSource.METRICS;
 
+	const timeAggregateOperators = [MetricAggregateOperator.RATE];
+	const spaceAggregateOperators = [MetricAggregateOperator.SUM];
+
 	return getQueryBuilderQueries({
 		autocompleteData,
 		groupBy,
 		legends,
 		filterItems,
 		dataSource,
+		timeAggregateOperators,
+		spaceAggregateOperators,
 	});
 };
 

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

@@ -25,6 +25,8 @@ export const getQueryBuilderQueries = ({
 	aggregateOperator,
 	dataSource,
 	queryNameAndExpression,
+	timeAggregateOperators,
+	spaceAggregateOperators,
 }: BuilderQueriesProps): QueryBuilderData => ({
 	queryFormulas: [],
 	queryData: autocompleteData.map((item, index) => {
@@ -50,6 +52,8 @@ export const getQueryBuilderQueries = ({
 				op: 'AND',
 			},
 			reduceTo: 'avg',
+			spaceAggregation: spaceAggregateOperators[index],
+			timeAggregation: timeAggregateOperators[index],
 			dataSource,
 		};
 

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

@@ -83,6 +83,17 @@ export const latency = ({
 	const dataSource = isSpanMetricEnable ? DataSource.METRICS : DataSource.TRACES;
 	const queryNameAndExpression = QUERYNAME_AND_EXPRESSION;
 
+	const timeAggregateOperators = [
+		MetricAggregateOperator.EMPTY,
+		MetricAggregateOperator.EMPTY,
+		MetricAggregateOperator.EMPTY,
+	];
+	const spaceAggregateOperators = [
+		MetricAggregateOperator.P50,
+		MetricAggregateOperator.P90,
+		MetricAggregateOperator.P99,
+	];
+
 	return getQueryBuilderQueries({
 		autocompleteData,
 		legends,
@@ -90,6 +101,8 @@ export const latency = ({
 		aggregateOperator,
 		dataSource,
 		queryNameAndExpression,
+		timeAggregateOperators,
+		spaceAggregateOperators,
 	});
 };
 
@@ -510,11 +523,16 @@ export const operationPerSec = ({
 	const legends = OPERATION_LEGENDS;
 	const dataSource = DataSource.METRICS;
 
+	const timeAggregateOperators = [MetricAggregateOperator.RATE];
+	const spaceAggregateOperators = [MetricAggregateOperator.SUM];
+
 	return getQueryBuilderQueries({
 		autocompleteData,
 		legends,
 		filterItems,
 		dataSource,
+		timeAggregateOperators,
+		spaceAggregateOperators,
 	});
 };
 

frontend/src/container/MetricsApplication/Tabs/types.ts

@@ -29,6 +29,8 @@ export interface BuilderQueriesProps {
 	aggregateOperator?: string[];
 	dataSource: DataSource;
 	queryNameAndExpression?: string[];
+	timeAggregateOperators: MetricAggregateOperator[];
+	spaceAggregateOperators: MetricAggregateOperator[];
 }
 
 export interface BuilderQuerieswithFormulaProps {

frontend/src/container/MetricsApplication/constant.ts

@@ -2,18 +2,27 @@
 
 import { DownloadOptions } from 'container/Download/Download.types';
 import { MenuItemKeys } from 'container/GridCardLayout/WidgetHeader/contants';
+import {
+	MetricAggregateOperator,
+	TracesAggregatorOperator,
+} from 'types/common/queryBuilder';
 
 export const legend = {
 	address: '{{address}}',
 };
 
 export const QUERYNAME_AND_EXPRESSION = ['A', 'B', 'C'];
-export const LATENCY_AGGREGATEOPERATOR = ['p50', 'p90', 'p99'];
-export const LATENCY_AGGREGATEOPERATOR_SPAN_METRICS = [
-	'hist_quantile_50',
-	'hist_quantile_90',
-	'hist_quantile_99',
+export const LATENCY_AGGREGATEOPERATOR = [
+	TracesAggregatorOperator.P50,
+	TracesAggregatorOperator.P90,
+	TracesAggregatorOperator.P99,
 ];
+export const LATENCY_AGGREGATEOPERATOR_SPAN_METRICS = [
+	MetricAggregateOperator.P50,
+	MetricAggregateOperator.P90,
+	MetricAggregateOperator.P99,
+];
+
 export const OPERATION_LEGENDS = ['Operations'];
 
 export const MENU_ITEMS = [MenuItemKeys.View, MenuItemKeys.CreateAlerts];
@@ -21,8 +30,21 @@ export const MENU_ITEMS = [MenuItemKeys.View, MenuItemKeys.CreateAlerts];
 export enum FORMULA {
 	ERROR_PERCENTAGE = 'A*100/B',
 	DATABASE_CALLS_AVG_DURATION = 'A/B',
+	// The apdex formula is (satisfied_count + 0.5 * tolerating_count + 0 * frustating_count) / total_count
+	// The satisfied_count is B, tolerating_count is C, total_count is A
+	// But why do we have (B+C)/2 instead of B + C/2?
+	// The way we issue the query is latency <= threshold, which means we over count i.e
+	// query B => durationNano <= 500ms
+	// query C => durationNano <= 2000ms
+	// Since <= 2000ms includes <= 500ms, we over count, to correct we subtract B/2
+	// so the full expression would be (B + C/2) - B/2 = (B+C)/2
 	APDEX_TRACES = '((B + C)/2)/A',
-	APDEX_DELTA_SPAN_METRICS = '((B + C)/2)/A',
+	// Does the same not apply for delta span metrics?
+	// No, because the delta metrics store the counts just for the current bucket
+	// so we don't need to subtract anything
+	APDEX_DELTA_SPAN_METRICS = '(B + C)/A',
+	// Cumulative span metrics store the counts for all buckets
+	// so we need to subtract B/2 to correct the over counting
 	APDEX_CUMULATIVE_SPAN_METRICS = '((B + C)/2)/A',
 }
 
@@ -53,6 +75,7 @@ export enum KeyOperationTableHeader {
 export enum MetricsType {
 	Tag = 'tag',
 	Resource = 'resource',
+	Scope = 'scope',
 }
 
 export enum WidgetKeys {

frontend/src/container/OnboardingContainer/Modules/APM/Java/md-docs/SpringBoot/Kubernetes/springBoot-kubernetes-runApplication-consumers.md

@@ -0,0 +1,32 @@
+ 
+
+Once you are done instrumenting your Java application, you can run it using the below commands
+
+**Note:**
+- Ensure you have Java and Maven installed. Compile your Java consumer applications: Ensure your consumer apps are compiled and ready to run.
+
+**Run Consumer App with Java Agent:**
+
+```bash
+java -javaagent:/path/to/opentelemetry-javaagent.jar \
+     -Dotel.service.name=consumer-svc \
+     -Dotel.traces.exporter=otlp \
+     -Dotel.metrics.exporter=otlp \
+     -Dotel.logs.exporter=otlp \
+     -Dotel.instrumentation.kafka.producer-propagation.enabled=true \
+     -Dotel.instrumentation.kafka.experimental-span-attributes=true \
+     -Dotel.instrumentation.kafka.metric-reporter.enabled=true \
+     -jar /path/to/your/consumer.jar
+```
+
+<path> - update it to the path where you downloaded the Java JAR agent in previous step
+<my-app> - Jar file of your application
+
+&nbsp;
+
+**Note:**
+- In case you're dockerising your application, make sure to dockerise it along with OpenTelemetry instrumentation done in previous step.
+
+&nbsp;
+
+If you encounter any difficulties, please consult the [troubleshooting section](https://signoz.io/docs/instrumentation/springboot/#troubleshooting-your-installation) for assistance.

frontend/src/container/OnboardingContainer/Modules/APM/Java/md-docs/SpringBoot/Kubernetes/springBoot-kubernetes-runApplication-producers.md

@@ -0,0 +1,29 @@
+ 
+
+Once you are done instrumenting your Java application, you can run it using the below commands
+
+**Note:**
+- Ensure you have Java and Maven installed. Compile your Java producer applications: Ensure your producer apps are compiled and ready to run.
+
+**Run Producer App with Java Agent:**
+
+```bash
+java -javaagent:/path/to/opentelemetry-javaagent.jar \
+     -Dotel.service.name=producer-svc \
+     -Dotel.traces.exporter=otlp \
+     -Dotel.metrics.exporter=otlp \
+     -Dotel.logs.exporter=otlp \
+     -jar /path/to/your/producer.jar
+```
+
+<path> - update it to the path where you downloaded the Java JAR agent in previous step
+<my-app> - Jar file of your application
+
+&nbsp;
+
+**Note:**
+- In case you're dockerising your application, make sure to dockerise it along with OpenTelemetry instrumentation done in previous step.
+
+&nbsp;
+
+If you encounter any difficulties, please consult the [troubleshooting section](https://signoz.io/docs/instrumentation/springboot/#troubleshooting-your-installation) for assistance.

frontend/src/container/OnboardingContainer/OnboardingContainer.tsx

@@ -312,7 +312,7 @@ export default function Onboarding(): JSX.Element {
 					<div
 						onClick={(): void => {
 							logEvent('Onboarding V2: Skip Button Clicked', {});
-							history.push('/');
+							history.push(ROUTES.APPLICATION);
 						}}
 						className="skip-to-console"
 					>

frontend/src/container/OnboardingContainer/Steps/ConnectionStatus/ConnectionStatus.tsx

@@ -6,11 +6,16 @@ import {
 	LoadingOutlined,
 } from '@ant-design/icons';
 import logEvent from 'api/common/logEvent';
+import { QueryParams } from 'constants/query';
 import Header from 'container/OnboardingContainer/common/Header/Header';
 import { useOnboardingContext } from 'container/OnboardingContainer/context/OnboardingContext';
+import { useOnboardingStatus } from 'hooks/messagingQueue / onboarding/useOnboardingStatus';
 import { useQueryService } from 'hooks/useQueryService';
 import useResourceAttribute from 'hooks/useResourceAttribute';
 import { convertRawQueriesToTraceSelectedTags } from 'hooks/useResourceAttribute/utils';
+import useUrlQuery from 'hooks/useUrlQuery';
+import MessagingQueueHealthCheck from 'pages/MessagingQueues/MessagingQueueHealthCheck/MessagingQueueHealthCheck';
+import { getAttributeDataFromOnboardingStatus } from 'pages/MessagingQueues/MessagingQueuesUtils';
 import { useEffect, useMemo, useState } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
 import { AppState } from 'store/reducers';
@@ -27,6 +32,12 @@ export default function ConnectionStatus(): JSX.Element {
 		GlobalReducer
 	>((state) => state.globalTime);
 
+	const urlQuery = useUrlQuery();
+	const getStartedSource = urlQuery.get(QueryParams.getStartedSource);
+	const getStartedSourceService = urlQuery.get(
+		QueryParams.getStartedSourceService,
+	);
+
 	const {
 		serviceName,
 		selectedDataSource,
@@ -57,8 +68,69 @@ export default function ConnectionStatus(): JSX.Element {
 		maxTime,
 		selectedTime,
 		selectedTags,
+		options: {
+			enabled: getStartedSource !== 'kafka',
+		},
 	});
 
+	const [pollInterval, setPollInterval] = useState<number | false>(10000);
+	const {
+		data: onbData,
+		error: onbErr,
+		isFetching: onbFetching,
+	} = useOnboardingStatus(
+		{
+			enabled: getStartedSource === 'kafka',
+			refetchInterval: pollInterval,
+		},
+		getStartedSourceService || '',
+		'query-key-onboarding-status',
+	);
+
+	const [
+		shouldRetryOnboardingCall,
+		setShouldRetryOnboardingCall,
+	] = useState<boolean>(false);
+
+	useEffect(() => {
+		// runs only when the caller is coming from 'kafka' i.e. coming from Messaging Queues - setup helper
+		if (getStartedSource === 'kafka') {
+			if (onbData?.statusCode !== 200) {
+				setShouldRetryOnboardingCall(true);
+			} else if (onbData?.payload?.status === 'success') {
+				const attributeData = getAttributeDataFromOnboardingStatus(
+					onbData?.payload,
+				);
+				if (attributeData.overallStatus === 'success') {
+					setLoading(false);
+					setIsReceivingData(true);
+					setPollInterval(false);
+				} else {
+					setShouldRetryOnboardingCall(true);
+				}
+			}
+		}
+	}, [
+		shouldRetryOnboardingCall,
+		onbData,
+		onbErr,
+		onbFetching,
+		getStartedSource,
+	]);
+
+	useEffect(() => {
+		if (retryCount < 0 && getStartedSource === 'kafka') {
+			setPollInterval(false);
+			setLoading(false);
+		}
+	}, [retryCount, getStartedSource]);
+
+	useEffect(() => {
+		if (getStartedSource === 'kafka' && !onbFetching) {
+			setRetryCount((prevCount) => prevCount - 1);
+		}
+	}, [getStartedSource, onbData, onbFetching]);
+
 	const renderDocsReference = (): JSX.Element => {
 		switch (selectedDataSource?.name) {
 			case 'java':
@@ -192,25 +264,27 @@ export default function ConnectionStatus(): JSX.Element {
 	useEffect(() => {
 		let pollingTimer: string | number | NodeJS.Timer | undefined;
 
-		if (loading) {
-			pollingTimer = setInterval(() => {
-				// Trigger a refetch with the updated parameters
-				const updatedMinTime = (Date.now() - 15 * 60 * 1000) * 1000000;
-				const updatedMaxTime = Date.now() * 1000000;
+		if (getStartedSource !== 'kafka') {
+			if (loading) {
+				pollingTimer = setInterval(() => {
+					// Trigger a refetch with the updated parameters
+					const updatedMinTime = (Date.now() - 15 * 60 * 1000) * 1000000;
+					const updatedMaxTime = Date.now() * 1000000;
 
-				const payload = {
-					maxTime: updatedMaxTime,
-					minTime: updatedMinTime,
-					selectedTime,
-				};
+					const payload = {
+						maxTime: updatedMaxTime,
+						minTime: updatedMinTime,
+						selectedTime,
+					};
 
-				dispatch({
-					type: UPDATE_TIME_INTERVAL,
-					payload,
-				});
-			}, pollingInterval); // Same interval as pollingInterval
-		} else if (!loading && pollingTimer) {
-			clearInterval(pollingTimer);
+					dispatch({
+						type: UPDATE_TIME_INTERVAL,
+						payload,
+					});
+				}, pollingInterval); // Same interval as pollingInterval
+			} else if (!loading && pollingTimer) {
+				clearInterval(pollingTimer);
+			}
 		}
 
 		// Clean up the interval when the component unmounts
@@ -221,15 +295,24 @@ export default function ConnectionStatus(): JSX.Element {
 	}, [refetch, selectedTags, selectedTime, loading]);
 
 	useEffect(() => {
-		verifyApplicationData(data);
+		if (getStartedSource !== 'kafka') {
+			verifyApplicationData(data);
+		}
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [isServiceLoading, data, error, isError]);
 
 	useEffect(() => {
-		refetch();
+		if (getStartedSource !== 'kafka') {
+			refetch();
+		}
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, []);
 
+	const isQueryServiceLoading = useMemo(
+		() => isServiceLoading || loading || onbFetching,
+		[isServiceLoading, loading, onbFetching],
+	);
+
 	return (
 		<div className="connection-status-container">
 			<div className="full-docs-link">{renderDocsReference()}</div>
@@ -250,30 +333,42 @@ export default function ConnectionStatus(): JSX.Element {
 					<div className="label"> Status </div>
 
 					<div className="status">
-						{(loading || isServiceLoading) && <LoadingOutlined />}
-						{!(loading || isServiceLoading) && isReceivingData && (
-							<>
-								<CheckCircleTwoTone twoToneColor="#52c41a" />
-								<span> Success </span>
-							</>
-						)}
-						{!(loading || isServiceLoading) && !isReceivingData && (
-							<>
-								<CloseCircleTwoTone twoToneColor="#e84749" />
-								<span> Failed </span>
-							</>
-						)}
+						{isQueryServiceLoading && <LoadingOutlined />}
+						{!isQueryServiceLoading &&
+							isReceivingData &&
+							(getStartedSource !== 'kafka' ? (
+								<>
+									<CheckCircleTwoTone twoToneColor="#52c41a" />
+									<span> Success </span>
+								</>
+							) : (
+								<MessagingQueueHealthCheck
+									serviceToInclude={[getStartedSourceService || '']}
+								/>
+							))}
+						{!isQueryServiceLoading &&
+							!isReceivingData &&
+							(getStartedSource !== 'kafka' ? (
+								<>
+									<CloseCircleTwoTone twoToneColor="#e84749" />
+									<span> Failed </span>
+								</>
+							) : (
+								<MessagingQueueHealthCheck
+									serviceToInclude={[getStartedSourceService || '']}
+								/>
+							))}
 					</div>
 				</div>
 				<div className="details-info">
 					<div className="label"> Details </div>
 
 					<div className="details">
-						{(loading || isServiceLoading) && <div> Waiting for Update </div>}
-						{!(loading || isServiceLoading) && isReceivingData && (
+						{isQueryServiceLoading && <div> Waiting for Update </div>}
+						{!isQueryServiceLoading && isReceivingData && (
 							<div> Received data from the application successfully. </div>
 						)}
-						{!(loading || isServiceLoading) && !isReceivingData && (
+						{!isQueryServiceLoading && !isReceivingData && (
 							<div> Could not detect the install </div>
 						)}
 					</div>

frontend/src/container/OnboardingContainer/Steps/DataSource/DataSource.styles.scss

@@ -74,4 +74,11 @@ div[class*='-setup-instructions-container'] {
 	.dataSourceName {
 		color: var(--bg-slate-500);
 	}
-}
+}
+
+.supported-languages-container {
+	.disabled {
+		cursor: not-allowed;
+		opacity: 0.5;
+	}
+}

frontend/src/container/OnboardingContainer/Steps/DataSource/DataSource.tsx

@@ -6,15 +6,21 @@ import { LoadingOutlined } from '@ant-design/icons';
 import { Button, Card, Form, Input, Select, Space, Typography } from 'antd';
 import logEvent from 'api/common/logEvent';
 import cx from 'classnames';
+import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
 import { useOnboardingContext } from 'container/OnboardingContainer/context/OnboardingContext';
-import { useCases } from 'container/OnboardingContainer/OnboardingContainer';
+import {
+	ModulesMap,
+	useCases,
+} from 'container/OnboardingContainer/OnboardingContainer';
 import {
 	getDataSources,
 	getSupportedFrameworks,
 	hasFrameworks,
+	messagingQueueKakfaSupportedDataSources,
 } from 'container/OnboardingContainer/utils/dataSourceUtils';
 import { useNotifications } from 'hooks/useNotifications';
+import useUrlQuery from 'hooks/useUrlQuery';
 import { Blocks, Check } from 'lucide-react';
 import { useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
@@ -33,6 +39,8 @@ export default function DataSource(): JSX.Element {
 	const { t } = useTranslation(['common']);
 	const history = useHistory();
 
+	const getStartedSource = useUrlQuery().get(QueryParams.getStartedSource);
+
 	const {
 		serviceName,
 		selectedModule,
@@ -44,6 +52,9 @@ export default function DataSource(): JSX.Element {
 		updateSelectedFramework,
 	} = useOnboardingContext();
 
+	const isKafkaAPM =
+		getStartedSource === 'kafka' && selectedModule?.id === ModulesMap.APM;
+
 	const [supportedDataSources, setSupportedDataSources] = useState<
 		DataSourceType[]
 	>([]);
@@ -150,13 +161,19 @@ export default function DataSource(): JSX.Element {
 						className={cx(
 							'supported-language',
 							selectedDataSource?.name === dataSource.name ? 'selected' : '',
+							isKafkaAPM &&
+								!messagingQueueKakfaSupportedDataSources.includes(dataSource?.id || '')
+								? 'disabled'
+								: '',
 						)}
 						key={dataSource.name}
 						onClick={(): void => {
-							updateSelectedFramework(null);
-							updateSelectedEnvironment(null);
-							updateSelectedDataSource(dataSource);
-							form.setFieldsValue({ selectFramework: null });
+							if (!isKafkaAPM) {
+								updateSelectedFramework(null);
+								updateSelectedEnvironment(null);
+								updateSelectedDataSource(dataSource);
+								form.setFieldsValue({ selectFramework: null });
+							}
 						}}
 					>
 						<div>

frontend/src/container/OnboardingContainer/Steps/MarkdownStep/MarkdownStep.tsx

@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/ban-ts-comment */
 import { MarkdownRenderer } from 'components/MarkdownRenderer/MarkdownRenderer';
+import { QueryParams } from 'constants/query';
 import { ApmDocFilePaths } from 'container/OnboardingContainer/constants/apmDocFilePaths';
 import { AwsMonitoringDocFilePaths } from 'container/OnboardingContainer/constants/awsMonitoringDocFilePaths';
 import { AzureMonitoringDocFilePaths } from 'container/OnboardingContainer/constants/azureMonitoringDocFilePaths';
@@ -10,6 +11,7 @@ import {
 	useOnboardingContext,
 } from 'container/OnboardingContainer/context/OnboardingContext';
 import { ModulesMap } from 'container/OnboardingContainer/OnboardingContainer';
+import useUrlQuery from 'hooks/useUrlQuery';
 import { useEffect, useState } from 'react';
 
 export interface IngestionInfoProps {
@@ -31,6 +33,12 @@ export default function MarkdownStep(): JSX.Element {
 
 	const [markdownContent, setMarkdownContent] = useState('');
 
+	const urlQuery = useUrlQuery();
+	const getStartedSource = urlQuery.get(QueryParams.getStartedSource);
+	const getStartedSourceService = urlQuery.get(
+		QueryParams.getStartedSourceService,
+	);
+
 	const { step } = activeStep;
 
 	const getFilePath = (): any => {
@@ -54,6 +62,12 @@ export default function MarkdownStep(): JSX.Element {
 
 		path += `_${step?.id}`;
 
+		if (
+			getStartedSource === 'kafka' &&
+			path === 'APM_java_springBoot_kubernetes_recommendedSteps_runApplication' // todo: Sagar - Make this generic logic in followup PRs
+		) {
+			path += `_${getStartedSourceService}`;
+		}
 		return path;
 	};
 

frontend/src/container/OnboardingContainer/constants/apmDocFilePaths.ts

@@ -252,6 +252,8 @@ import APM_java_springBoot_docker_recommendedSteps_runApplication from '../Modul
 import APM_java_springBoot_kubernetes_recommendedSteps_setupOtelCollector from '../Modules/APM/Java/md-docs/SpringBoot/Kubernetes/springBoot-kubernetes-installOtelCollector.md';
 import APM_java_springBoot_kubernetes_recommendedSteps_instrumentApplication from '../Modules/APM/Java/md-docs/SpringBoot/Kubernetes/springBoot-kubernetes-instrumentApplication.md';
 import APM_java_springBoot_kubernetes_recommendedSteps_runApplication from '../Modules/APM/Java/md-docs/SpringBoot/Kubernetes/springBoot-kubernetes-runApplication.md';
+import APM_java_springBoot_kubernetes_recommendedSteps_runApplication_consumers from '../Modules/APM/Java/md-docs/SpringBoot/Kubernetes/springBoot-kubernetes-runApplication-consumers.md';
+import APM_java_springBoot_kubernetes_recommendedSteps_runApplication_producers from '../Modules/APM/Java/md-docs/SpringBoot/Kubernetes/springBoot-kubernetes-runApplication-producers.md';
 // SpringBoot-LinuxAMD64-quickstart
 import APM_java_springBoot_linuxAMD64_quickStart_instrumentApplication from '../Modules/APM/Java/md-docs/SpringBoot/LinuxAMD64/QuickStart/springBoot-linuxamd64-quickStart-instrumentApplication.md';
 import APM_java_springBoot_linuxAMD64_quickStart_runApplication from '../Modules/APM/Java/md-docs/SpringBoot/LinuxAMD64/QuickStart/springBoot-linuxamd64-quickStart-runApplication.md';
@@ -1053,6 +1055,8 @@ export const ApmDocFilePaths = {
 	APM_java_springBoot_kubernetes_recommendedSteps_setupOtelCollector,
 	APM_java_springBoot_kubernetes_recommendedSteps_instrumentApplication,
 	APM_java_springBoot_kubernetes_recommendedSteps_runApplication,
+	APM_java_springBoot_kubernetes_recommendedSteps_runApplication_producers,
+	APM_java_springBoot_kubernetes_recommendedSteps_runApplication_consumers,
 
 	// SpringBoot-LinuxAMD64-recommended
 	APM_java_springBoot_linuxAMD64_recommendedSteps_setupOtelCollector,

frontend/src/container/OnboardingContainer/utils/dataSourceUtils.ts

@@ -399,3 +399,5 @@ export const moduleRouteMap = {
 	[ModulesMap.AwsMonitoring]: ROUTES.GET_STARTED_AWS_MONITORING,
 	[ModulesMap.AzureMonitoring]: ROUTES.GET_STARTED_AZURE_MONITORING,
 };
+
+export const messagingQueueKakfaSupportedDataSources = ['java'];

frontend/src/container/OnboardingQuestionaire/AboutSigNozQuestions/AboutSigNozQuestions.tsx

@@ -0,0 +1,235 @@
+/* eslint-disable sonarjs/cognitive-complexity */
+import '../OnboardingQuestionaire.styles.scss';
+
+import { Color } from '@signozhq/design-tokens';
+import { Button, Input, Typography } from 'antd';
+import logEvent from 'api/common/logEvent';
+import { ArrowLeft, ArrowRight, CheckCircle } from 'lucide-react';
+import { useEffect, useState } from 'react';
+
+export interface SignozDetails {
+	hearAboutSignoz: string | null;
+	interestInSignoz: string | null;
+	otherInterestInSignoz: string | null;
+	otherAboutSignoz: string | null;
+}
+
+interface AboutSigNozQuestionsProps {
+	signozDetails: SignozDetails;
+	setSignozDetails: (details: SignozDetails) => void;
+	onNext: () => void;
+	onBack: () => void;
+}
+
+const hearAboutSignozOptions: Record<string, string> = {
+	search: 'Google / Search',
+	hackerNews: 'Hacker News',
+	linkedin: 'LinkedIn',
+	twitter: 'Twitter',
+	reddit: 'Reddit',
+	colleaguesFriends: 'Colleagues / Friends',
+};
+
+const interestedInOptions: Record<string, string> = {
+	savingCosts: 'Saving costs',
+	otelNativeStack: 'Interested in Otel-native stack',
+	allInOne: 'All in one (Logs, Metrics & Traces)',
+};
+
+export function AboutSigNozQuestions({
+	signozDetails,
+	setSignozDetails,
+	onNext,
+	onBack,
+}: AboutSigNozQuestionsProps): JSX.Element {
+	const [hearAboutSignoz, setHearAboutSignoz] = useState<string | null>(
+		signozDetails?.hearAboutSignoz || null,
+	);
+	const [otherAboutSignoz, setOtherAboutSignoz] = useState<string>(
+		signozDetails?.otherAboutSignoz || '',
+	);
+	const [interestInSignoz, setInterestInSignoz] = useState<string | null>(
+		signozDetails?.interestInSignoz || null,
+	);
+	const [otherInterestInSignoz, setOtherInterestInSignoz] = useState<string>(
+		signozDetails?.otherInterestInSignoz || '',
+	);
+	const [isNextDisabled, setIsNextDisabled] = useState<boolean>(true);
+
+	useEffect((): void => {
+		if (
+			hearAboutSignoz !== null &&
+			(hearAboutSignoz !== 'Others' || otherAboutSignoz !== '') &&
+			interestInSignoz !== null &&
+			(interestInSignoz !== 'Others' || otherInterestInSignoz !== '')
+		) {
+			setIsNextDisabled(false);
+		} else {
+			setIsNextDisabled(true);
+		}
+	}, [
+		hearAboutSignoz,
+		otherAboutSignoz,
+		interestInSignoz,
+		otherInterestInSignoz,
+	]);
+
+	const handleOnNext = (): void => {
+		setSignozDetails({
+			hearAboutSignoz,
+			otherAboutSignoz,
+			interestInSignoz,
+			otherInterestInSignoz,
+		});
+
+		logEvent('Org Onboarding: Answered', {
+			hearAboutSignoz,
+			otherAboutSignoz,
+			interestInSignoz,
+			otherInterestInSignoz,
+		});
+
+		onNext();
+	};
+
+	const handleOnBack = (): void => {
+		setSignozDetails({
+			hearAboutSignoz,
+			otherAboutSignoz,
+			interestInSignoz,
+			otherInterestInSignoz,
+		});
+
+		onBack();
+	};
+
+	return (
+		<div className="questions-container">
+			<Typography.Title level={3} className="title">
+				Tell Us About Your Interest in SigNoz
+			</Typography.Title>
+			<Typography.Paragraph className="sub-title">
+				We&apos;d love to know a little bit about you and your interest in SigNoz
+			</Typography.Paragraph>
+
+			<div className="questions-form-container">
+				<div className="questions-form">
+					<div className="form-group">
+						<div className="question">Where did you hear about SigNoz?</div>
+						<div className="two-column-grid">
+							{Object.keys(hearAboutSignozOptions).map((option: string) => (
+								<Button
+									key={option}
+									type="primary"
+									className={`onboarding-questionaire-button ${
+										hearAboutSignoz === option ? 'active' : ''
+									}`}
+									onClick={(): void => setHearAboutSignoz(option)}
+								>
+									{hearAboutSignozOptions[option]}
+									{hearAboutSignoz === option && (
+										<CheckCircle size={12} color={Color.BG_FOREST_500} />
+									)}
+								</Button>
+							))}
+
+							{hearAboutSignoz === 'Others' ? (
+								<Input
+									type="text"
+									className="onboarding-questionaire-other-input"
+									placeholder="How you got to know about us"
+									value={otherAboutSignoz}
+									autoFocus
+									addonAfter={
+										otherAboutSignoz !== '' ? (
+											<CheckCircle size={12} color={Color.BG_FOREST_500} />
+										) : (
+											''
+										)
+									}
+									onChange={(e): void => setOtherAboutSignoz(e.target.value)}
+								/>
+							) : (
+								<Button
+									type="primary"
+									className={`onboarding-questionaire-button ${
+										hearAboutSignoz === 'Others' ? 'active' : ''
+									}`}
+									onClick={(): void => setHearAboutSignoz('Others')}
+								>
+									Others
+								</Button>
+							)}
+						</div>
+					</div>
+
+					<div className="form-group">
+						<div className="question">What got you interested in SigNoz?</div>
+						<div className="two-column-grid">
+							{Object.keys(interestedInOptions).map((option: string) => (
+								<Button
+									key={option}
+									type="primary"
+									className={`onboarding-questionaire-button ${
+										interestInSignoz === option ? 'active' : ''
+									}`}
+									onClick={(): void => setInterestInSignoz(option)}
+								>
+									{interestedInOptions[option]}
+									{interestInSignoz === option && (
+										<CheckCircle size={12} color={Color.BG_FOREST_500} />
+									)}
+								</Button>
+							))}
+
+							{interestInSignoz === 'Others' ? (
+								<Input
+									type="text"
+									className="onboarding-questionaire-other-input"
+									placeholder="Please specify your interest"
+									value={otherInterestInSignoz}
+									autoFocus
+									addonAfter={
+										otherInterestInSignoz !== '' ? (
+											<CheckCircle size={12} color={Color.BG_FOREST_500} />
+										) : (
+											''
+										)
+									}
+									onChange={(e): void => setOtherInterestInSignoz(e.target.value)}
+								/>
+							) : (
+								<Button
+									type="primary"
+									className={`onboarding-questionaire-button ${
+										interestInSignoz === 'Others' ? 'active' : ''
+									}`}
+									onClick={(): void => setInterestInSignoz('Others')}
+								>
+									Others
+								</Button>
+							)}
+						</div>
+					</div>
+				</div>
+
+				<div className="next-prev-container">
+					<Button type="default" className="next-button" onClick={handleOnBack}>
+						<ArrowLeft size={14} />
+						Back
+					</Button>
+
+					<Button
+						type="primary"
+						className={`next-button ${isNextDisabled ? 'disabled' : ''}`}
+						onClick={handleOnNext}
+						disabled={isNextDisabled}
+					>
+						Next
+						<ArrowRight size={14} />
+					</Button>
+				</div>
+			</div>
+		</div>
+	);
+}

frontend/src/container/OnboardingQuestionaire/InviteTeamMembers/InviteTeamMembers.styles.scss

@@ -0,0 +1,122 @@
+.team-member-container {
+	display: flex;
+	align-items: center;
+
+	.team-member-role-select {
+		width: 20%;
+
+		.ant-select-selector {
+			border: 1px solid #1d212d;
+			border-top-left-radius: 0px;
+			border-bottom-left-radius: 0px;
+		}
+	}
+
+	.team-member-email-input {
+		width: 80%;
+		background-color: #121317;
+		border-top-right-radius: 0px;
+		border-bottom-right-radius: 0px;
+
+		.ant-input,
+		.ant-input-group-addon {
+			background-color: #121317 !important;
+			border-right: 0px;
+			border-top-right-radius: 0px;
+			border-bottom-right-radius: 0px;
+		}
+	}
+}
+
+.questions-form-container {
+	.error-message-container,
+	.success-message-container,
+	.partially-sent-invites-container {
+		border-radius: 4px;
+		width: 100%;
+		display: flex;
+		align-items: center;
+
+		.error-message,
+		.success-message {
+			font-size: 12px;
+			font-weight: 400;
+
+			display: flex;
+			align-items: center;
+			gap: 8px;
+		}
+	}
+
+	.invite-users-error-message-container,
+	.invite-users-success-message-container {
+		display: flex;
+		flex-direction: column;
+		align-items: flex-start;
+		gap: 8px;
+
+		.success-message {
+			color: var(--bg-success-500, #00b37e);
+		}
+	}
+
+	.partially-sent-invites-container {
+		margin-top: 16px;
+		padding: 8px;
+		border: 1px solid #1d212d;
+		background-color: #121317;
+
+		display: flex;
+		flex-direction: column;
+		align-items: flex-start;
+		gap: 8px;
+
+		.partially-sent-invites-message {
+			color: var(--bg-warning-500, #fbbd23);
+
+			font-size: 12px;
+			font-weight: 400;
+
+			display: flex;
+			align-items: center;
+			gap: 8px;
+		}
+	}
+}
+
+.lightMode {
+	.team-member-container {
+		.team-member-role-select {
+			.ant-select-selector {
+				border: 1px solid var(--bg-vanilla-300);
+			}
+		}
+
+		.team-member-email-input {
+			background-color: var(--bg-vanilla-100);
+
+			.ant-input,
+			.ant-input-group-addon {
+				background-color: var(--bg-vanilla-100) !important;
+			}
+		}
+	}
+
+	.questions-form-container {
+		.invite-users-error-message-container,
+		.invite-users-success-message-container {
+			.success-message {
+				color: var(--bg-success-500, #00b37e);
+			}
+		}
+
+		.partially-sent-invites-container {
+			border: 1px solid var(--bg-vanilla-300);
+			background-color: var(--bg-vanilla-100);
+
+			.partially-sent-invites-message {
+				color: var(--bg-warning-500, #fbbd23);
+			}
+		}
+	}
+}

frontend/src/container/OnboardingQuestionaire/InviteTeamMembers/InviteTeamMembers.tsx

@@ -0,0 +1,450 @@
+import './InviteTeamMembers.styles.scss';
+
+import { Color } from '@signozhq/design-tokens';
+import { Button, Input, Select, Typography } from 'antd';
+import logEvent from 'api/common/logEvent';
+import inviteUsers from 'api/user/inviteUsers';
+import { AxiosError } from 'axios';
+import { cloneDeep, debounce, isEmpty } from 'lodash-es';
+import {
+	ArrowLeft,
+	ArrowRight,
+	CheckCircle,
+	Loader2,
+	Plus,
+	TriangleAlert,
+	X,
+} from 'lucide-react';
+import { useCallback, useEffect, useState } from 'react';
+import { useMutation } from 'react-query';
+import { SuccessResponse } from 'types/api';
+import {
+	FailedInvite,
+	InviteUsersResponse,
+	SuccessfulInvite,
+} from 'types/api/user/inviteUsers';
+import { v4 as uuid } from 'uuid';
+
+interface TeamMember {
+	email: string;
+	role: string;
+	name: string;
+	frontendBaseUrl: string;
+	id: string;
+}
+
+interface InviteTeamMembersProps {
+	isLoading: boolean;
+	teamMembers: TeamMember[] | null;
+	setTeamMembers: (teamMembers: TeamMember[]) => void;
+	onNext: () => void;
+	onBack: () => void;
+}
+
+function InviteTeamMembers({
+	isLoading,
+	teamMembers,
+	setTeamMembers,
+	onNext,
+	onBack,
+}: InviteTeamMembersProps): JSX.Element {
+	const [teamMembersToInvite, setTeamMembersToInvite] = useState<
+		TeamMember[] | null
+	>(teamMembers);
+	const [emailValidity, setEmailValidity] = useState<Record<string, boolean>>(
+		{},
+	);
+	const [hasInvalidEmails, setHasInvalidEmails] = useState<boolean>(false);
+
+	const [hasErrors, setHasErrors] = useState<boolean>(true);
+
+	const [error, setError] = useState<string | null>(null);
+
+	const [inviteUsersErrorResponse, setInviteUsersErrorResponse] = useState<
+		string[] | null
+	>(null);
+
+	const [inviteUsersSuccessResponse, setInviteUsersSuccessResponse] = useState<
+		string[] | null
+	>(null);
+
+	const [disableNextButton, setDisableNextButton] = useState<boolean>(false);
+
+	const defaultTeamMember: TeamMember = {
+		email: '',
+		role: 'EDITOR',
+		name: '',
+		frontendBaseUrl: window.location.origin,
+		id: '',
+	};
+
+	useEffect(() => {
+		if (isEmpty(teamMembers)) {
+			const teamMember = {
+				...defaultTeamMember,
+				id: uuid(),
+			};
+
+			setTeamMembersToInvite([teamMember]);
+		}
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [teamMembers]);
+
+	const handleAddTeamMember = (): void => {
+		const newTeamMember = {
+			...defaultTeamMember,
+			id: uuid(),
+		};
+		setTeamMembersToInvite((prev) => [...(prev || []), newTeamMember]);
+	};
+
+	const handleRemoveTeamMember = (id: string): void => {
+		setTeamMembersToInvite((prev) => (prev || []).filter((m) => m.id !== id));
+	};
+
+	// Validation function to check all users
+	const validateAllUsers = (): boolean => {
+		let isValid = true;
+
+		const updatedValidity: Record<string, boolean> = {};
+
+		teamMembersToInvite?.forEach((member) => {
+			const emailValid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(member.email);
+			if (!emailValid || !member.email) {
+				isValid = false;
+				setHasInvalidEmails(true);
+			}
+			updatedValidity[member.id!] = emailValid;
+		});
+
+		setEmailValidity(updatedValidity);
+
+		return isValid;
+	};
+
+	const parseInviteUsersSuccessResponse = (
+		response: SuccessfulInvite[],
+	): string[] => response.map((invite) => `${invite.email} - Invite Sent`);
+
+	const parseInviteUsersErrorResponse = (response: FailedInvite[]): string[] =>
+		response.map((invite) => `${invite.email} - ${invite.error}`);
+
+	const handleError = (error: AxiosError): void => {
+		const errorMessage = error.response?.data as InviteUsersResponse;
+
+		if (errorMessage?.status === 'failure') {
+			setHasErrors(true);
+
+			const failedInvitesErrorResponse = parseInviteUsersErrorResponse(
+				errorMessage.failed_invites,
+			);
+
+			setInviteUsersErrorResponse(failedInvitesErrorResponse);
+		}
+	};
+
+	const handleInviteUsersSuccess = (
+		response: SuccessResponse<InviteUsersResponse>,
+	): void => {
+		const inviteUsersResponse = response.payload as InviteUsersResponse;
+
+		if (inviteUsersResponse?.status === 'success') {
+			const successfulInvites = parseInviteUsersSuccessResponse(
+				inviteUsersResponse.successful_invites,
+			);
+
+			setDisableNextButton(true);
+
+			setError(null);
+			setHasErrors(false);
+			setInviteUsersErrorResponse(null);
+
+			setInviteUsersSuccessResponse(successfulInvites);
+
+			logEvent('Org Onboarding: Invite Team Members Success', {
+				teamMembers: teamMembersToInvite,
+				totalInvites: inviteUsersResponse.summary.total_invites,
+				successfulInvites: inviteUsersResponse.summary.successful_invites,
+				failedInvites: inviteUsersResponse.summary.failed_invites,
+			});
+
+			setTimeout(() => {
+				setDisableNextButton(false);
+				onNext();
+			}, 1000);
+		} else if (inviteUsersResponse?.status === 'partial_success') {
+			const successfulInvites = parseInviteUsersSuccessResponse(
+				inviteUsersResponse.successful_invites,
+			);
+
+			setInviteUsersSuccessResponse(successfulInvites);
+
+			logEvent('Org Onboarding: Invite Team Members Partial Success', {
+				teamMembers: teamMembersToInvite,
+				totalInvites: inviteUsersResponse.summary.total_invites,
+				successfulInvites: inviteUsersResponse.summary.successful_invites,
+				failedInvites: inviteUsersResponse.summary.failed_invites,
+			});
+
+			if (inviteUsersResponse.failed_invites.length > 0) {
+				setHasErrors(true);
+
+				setInviteUsersErrorResponse(
+					parseInviteUsersErrorResponse(inviteUsersResponse.failed_invites),
+				);
+			}
+		}
+	};
+
+	const { mutate: sendInvites, isLoading: isSendingInvites } = useMutation(
+		inviteUsers,
+		{
+			onSuccess: (response: SuccessResponse<InviteUsersResponse>): void => {
+				handleInviteUsersSuccess(response);
+			},
+			onError: (error: AxiosError): void => {
+				logEvent('Org Onboarding: Invite Team Members Failed', {
+					teamMembers: teamMembersToInvite,
+				});
+
+				handleError(error);
+			},
+		},
+	);
+
+	const handleNext = (): void => {
+		if (validateAllUsers()) {
+			setTeamMembers(teamMembersToInvite || []);
+
+			setHasInvalidEmails(false);
+			setError(null);
+			setHasErrors(false);
+			setInviteUsersErrorResponse(null);
+			setInviteUsersSuccessResponse(null);
+
+			sendInvites({
+				users: teamMembersToInvite || [],
+			});
+		}
+	};
+
+	// eslint-disable-next-line react-hooks/exhaustive-deps
+	const debouncedValidateEmail = useCallback(
+		debounce((email: string, memberId: string) => {
+			const isValid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+			setEmailValidity((prev) => ({ ...prev, [memberId]: isValid }));
+		}, 500),
+		[],
+	);
+
+	const handleEmailChange = (
+		e: React.ChangeEvent<HTMLInputElement>,
+		member: TeamMember,
+	): void => {
+		const { value } = e.target;
+		const updatedMembers = cloneDeep(teamMembersToInvite || []);
+
+		const memberToUpdate = updatedMembers.find((m) => m.id === member.id);
+		if (memberToUpdate) {
+			memberToUpdate.email = value;
+			setTeamMembersToInvite(updatedMembers);
+			debouncedValidateEmail(value, member.id!);
+		}
+	};
+
+	const handleRoleChange = (role: string, member: TeamMember): void => {
+		const updatedMembers = cloneDeep(teamMembersToInvite || []);
+		const memberToUpdate = updatedMembers.find((m) => m.id === member.id);
+		if (memberToUpdate) {
+			memberToUpdate.role = role;
+			setTeamMembersToInvite(updatedMembers);
+		}
+	};
+
+	const handleDoLater = (): void => {
+		logEvent('Org Onboarding: Clicked Do Later', {
+			currentPageID: 4,
+		});
+
+		onNext();
+	};
+
+	return (
+		<div className="questions-container">
+			<Typography.Title level={3} className="title">
+				Invite your team members
+			</Typography.Title>
+			<Typography.Paragraph className="sub-title">
+				The more your team uses SigNoz, the stronger your observability. Share
+				dashboards, collaborate on alerts, and troubleshoot faster together.
+			</Typography.Paragraph>
+
+			<div className="questions-form-container">
+				<div className="questions-form invite-team-members-form">
+					<div className="form-group">
+						<div className="question-label">
+							Collaborate with your team
+							<div className="question-sub-label">
+								Invite your team to the SigNoz workspace
+							</div>
+						</div>
+
+						<div className="invite-team-members-container">
+							{teamMembersToInvite?.map((member) => (
+								<div className="team-member-container" key={member.id}>
+									<Input
+										placeholder="your-teammate@org.com"
+										value={member.email}
+										type="email"
+										required
+										autoFocus
+										autoComplete="off"
+										className="team-member-email-input"
+										onChange={(e: React.ChangeEvent<HTMLInputElement>): void =>
+											handleEmailChange(e, member)
+										}
+										addonAfter={
+											// eslint-disable-next-line no-nested-ternary
+											emailValidity[member.id!] === undefined ? null : emailValidity[
+													member.id!
+											  ] ? (
+												<CheckCircle size={14} color={Color.BG_FOREST_500} />
+											) : (
+												<TriangleAlert size={14} color={Color.BG_SIENNA_500} />
+											)
+										}
+									/>
+									<Select
+										defaultValue={member.role}
+										onChange={(value): void => handleRoleChange(value, member)}
+										className="team-member-role-select"
+									>
+										<Select.Option value="VIEWER">Viewer</Select.Option>
+										<Select.Option value="EDITOR">Editor</Select.Option>
+										<Select.Option value="ADMIN">Admin</Select.Option>
+									</Select>
+
+									{teamMembersToInvite?.length > 1 && (
+										<Button
+											type="primary"
+											className="remove-team-member-button"
+											icon={<X size={14} />}
+											onClick={(): void => handleRemoveTeamMember(member.id)}
+										/>
+									)}
+								</div>
+							))}
+						</div>
+
+						<div className="invite-team-members-add-another-member-container">
+							<Button
+								type="primary"
+								className="add-another-member-button"
+								icon={<Plus size={14} />}
+								onClick={handleAddTeamMember}
+							>
+								Member
+							</Button>
+						</div>
+					</div>
+
+					{hasInvalidEmails && (
+						<div className="error-message-container">
+							<Typography.Text className="error-message" type="danger">
+								<TriangleAlert size={14} /> Please enter valid emails for all team
+								members
+							</Typography.Text>
+						</div>
+					)}
+
+					{error && (
+						<div className="error-message-container">
+							<Typography.Text className="error-message" type="danger">
+								<TriangleAlert size={14} /> {error}
+							</Typography.Text>
+						</div>
+					)}
+
+					{hasErrors && (
+						<>
+							{/* show only when invites are sent successfully & partial error is present */}
+							{inviteUsersSuccessResponse && inviteUsersErrorResponse && (
+								<div className="success-message-container invite-users-success-message-container">
+									{inviteUsersSuccessResponse?.map((success, index) => (
+										<Typography.Text
+											className="success-message"
+											// eslint-disable-next-line react/no-array-index-key
+											key={`${success}-${index}`}
+										>
+											<CheckCircle size={14} /> {success}
+										</Typography.Text>
+									))}
+								</div>
+							)}
+
+							<div className="error-message-container invite-users-error-message-container">
+								{inviteUsersErrorResponse?.map((error, index) => (
+									<Typography.Text
+										className="error-message"
+										type="danger"
+										// eslint-disable-next-line react/no-array-index-key
+										key={`${error}-${index}`}
+									>
+										<TriangleAlert size={14} /> {error}
+									</Typography.Text>
+								))}
+							</div>
+						</>
+					)}
+				</div>
+
+				{/* Partially sent invites */}
+				{inviteUsersSuccessResponse && inviteUsersErrorResponse && (
+					<div className="partially-sent-invites-container">
+						<Typography.Text className="partially-sent-invites-message">
+							<TriangleAlert size={14} />
+							Some invites were sent successfully. Please fix the errors above and
+							resend invites.
+						</Typography.Text>
+
+						<Typography.Text className="partially-sent-invites-message">
+							You can click on I&apos;ll do this later to go to next step.
+						</Typography.Text>
+					</div>
+				)}
+
+				<div className="next-prev-container">
+					<Button type="default" className="next-button" onClick={onBack}>
+						<ArrowLeft size={14} />
+						Back
+					</Button>
+
+					<Button
+						type="primary"
+						className="next-button"
+						onClick={handleNext}
+						loading={isSendingInvites || isLoading || disableNextButton}
+					>
+						Send Invites
+						<ArrowRight size={14} />
+					</Button>
+				</div>
+
+				<div className="do-later-container">
+					<Button
+						type="link"
+						className="do-later-button"
+						onClick={handleDoLater}
+						disabled={isSendingInvites || disableNextButton}
+					>
+						{isLoading && <Loader2 className="animate-spin" size={16} />}
+
+						<span>I&apos;ll do this later</span>
+					</Button>
+				</div>
+			</div>
+		</div>
+	);
+}
+
+export default InviteTeamMembers;

frontend/src/container/OnboardingQuestionaire/OnboardingFooter/OnboardingFooter.styles.scss

@@ -0,0 +1,49 @@
+.footer-main-container {
+	display: flex;
+	justify-content: center;
+	box-sizing: border-box;
+}
+
+.footer-container {
+	display: inline-flex;
+	height: 36px;
+	padding: 12px;
+	justify-content: center;
+	align-items: center;
+	gap: 32px;
+	flex-shrink: 0;
+	border-radius: 4px;
+	border: 1px solid var(--Greyscale-Slate-500, #161922);
+	background: var(--Ink-400, #121317);
+
+	width: 100%;
+	max-width: 600px;
+}
+
+.footer-container .footer-content {
+	display: flex;
+	align-items: center;
+	gap: 10px;
+}
+
+.footer-container .footer-link {
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	color: #c0c1c3;
+}
+
+.footer-container .footer-text {
+	color: var(--Vanilla-400, var(--Greyscale-Vanilla-400, #c0c1c3));
+	font-size: 12px;
+	font-style: normal;
+	font-weight: 400;
+	line-height: normal;
+	letter-spacing: 0.2px;
+}
+
+.footer-container .footer-dot {
+	width: 4px;
+	height: 4px;
+	fill: var(--Greyscale-Slate-200, #2c3140);
+}

frontend/src/container/OnboardingQuestionaire/OnboardingFooter/OnboardingFooter.tsx

@@ -0,0 +1,31 @@
+import './OnboardingFooter.styles.scss';
+
+import { Dot } from 'lucide-react';
+
+export function OnboardingFooter(): JSX.Element {
+	return (
+		<section className="footer-main-container">
+			<div className="footer-container">
+				<a
+					href="https://trust.signoz.io/"
+					target="_blank"
+					className="footer-content"
+					rel="noreferrer"
+				>
+					<img src="/logos/hippa.svg" alt="HIPPA" className="footer-logo" />
+					<span className="footer-text">HIPPA</span>
+				</a>
+				<Dot size={24} color="#2C3140" />
+				<a
+					href="https://trust.signoz.io/"
+					target="_blank"
+					className="footer-content"
+					rel="noreferrer"
+				>
+					<img src="/logos/soc2.svg" alt="SOC2" className="footer-logo" />
+					<span className="footer-text">SOC2</span>
+				</a>
+			</div>
+		</section>
+	);
+}

frontend/src/container/OnboardingQuestionaire/OnboardingFooter/index.ts

@@ -0,0 +1 @@
+export { OnboardingFooter } from './OnboardingFooter';

frontend/src/container/OnboardingQuestionaire/OnboardingHeader/OnboardingHeader.styles.scss

@@ -0,0 +1,65 @@
+.header-container {
+	width: 100%;
+	display: flex;
+	justify-content: space-between;
+	align-items: center;
+	padding: 12px 0px;
+
+	box-sizing: border-box;
+}
+
+.header-container .logo-container {
+	display: flex;
+	align-items: center;
+	gap: 10px;
+}
+
+.header-container .logo-container img {
+	height: 17.5px;
+	width: 17.5px;
+}
+
+.header-container .logo-text {
+	font-family: 'Work Sans', sans-serif;
+	color: var(--bg-vanilla-100);
+	font-size: 15.4px;
+	font-style: normal;
+	font-weight: 500;
+	line-height: 17.5px;
+}
+
+.header-container .get-help-container {
+	display: flex;
+	width: 113px;
+	height: 32px;
+	padding: 6px;
+	justify-content: center;
+	align-items: center;
+	gap: 6px;
+	flex-shrink: 0;
+	border-radius: 2px;
+	border: 1px solid var(--bg-slate-400);
+	background: var(--bg-ink-300);
+	box-shadow: none;
+}
+
+.header-container .get-help-container img {
+	width: 12px;
+	height: 12px;
+	flex-shrink: 0;
+}
+
+.header-container .get-help-text {
+	color: var(--bg-vanilla-400);
+	font-size: 12px;
+	font-style: normal;
+	font-weight: 400;
+	line-height: 10px;
+	letter-spacing: 0.12px;
+}
+
+.lightMode {
+	.header-container .logo-text {
+		color: var(--bg-slate-300);
+	}
+}

frontend/src/container/OnboardingQuestionaire/OnboardingHeader/OnboardingHeader.tsx

@@ -0,0 +1,12 @@
+import './OnboardingHeader.styles.scss';
+
+export function OnboardingHeader(): JSX.Element {
+	return (
+		<div className="header-container">
+			<div className="logo-container">
+				<img src="/Logos/signoz-brand-logo.svg" alt="SigNoz" />
+				<span className="logo-text">SigNoz</span>
+			</div>
+		</div>
+	);
+}

frontend/src/container/OnboardingQuestionaire/OnboardingHeader/index.ts

@@ -0,0 +1 @@
+export { OnboardingHeader } from './OnboardingHeader';

frontend/src/container/OnboardingQuestionaire/OnboardingQuestionaire.styles.scss

@@ -0,0 +1,597 @@
+.onboarding-questionaire-container {
+	width: 100%;
+	display: flex;
+	margin: 0 auto;
+	align-items: center;
+	flex-direction: column;
+	height: 100vh;
+	max-width: 1176px;
+
+	.onboarding-questionaire-header {
+		width: 100%;
+		display: flex;
+		justify-content: center;
+		align-items: center;
+
+		height: 56px;
+	}
+
+	.onboarding-questionaire-content {
+		height: calc(100vh - 56px - 60px);
+		width: 100%;
+		display: flex;
+		flex-direction: column;
+		overflow-y: auto;
+
+		.questions-container {
+			color: var(--bg-vanilla-100, #fff);
+			font-family: Inter;
+			font-size: 24px;
+			font-style: normal;
+			font-weight: 600;
+			line-height: 32px;
+			max-width: 600px;
+			margin: 0 auto;
+			border-radius: 8px;
+			max-height: 100%;
+		}
+
+		.title {
+			color: var(--bg-vanilla-100) !important;
+			font-size: 24px !important;
+			line-height: 32px !important;
+			margin-bottom: 8px !important;
+		}
+
+		.sub-title {
+			color: var(--bg-vanilla-400) !important;
+			font-size: 14px !important;
+			font-style: normal;
+			font-weight: 400 !important;
+			line-height: 24px !important;
+			margin-top: 0px !important;
+			margin-bottom: 24px !important;
+		}
+
+		.questions-form-container {
+			max-width: 600px;
+			width: 600px;
+			margin: 0 auto;
+		}
+
+		.questions-form {
+			width: 100%;
+			display: flex;
+			min-height: 420px;
+			padding: 20px 24px 24px 24px;
+			flex-direction: column;
+			align-items: center;
+			gap: 24px;
+			border-radius: 4px;
+			border: 1px solid var(--bg-slate-500);
+			background: var(--bg-ink-400);
+
+			.ant-form-item {
+				margin-bottom: 0px !important;
+
+				.ant-form-item-label {
+					label {
+						color: var(--bg-vanilla-100) !important;
+						font-size: 13px !important;
+						font-weight: 500;
+						line-height: 20px;
+					}
+				}
+			}
+
+			&.invite-team-members-form {
+				min-height: calc(420px - 24px);
+				max-height: calc(420px - 24px);
+
+				.invite-team-members-container {
+					max-height: 260px;
+					overflow-y: auto;
+
+					&::-webkit-scrollbar {
+						width: 0.1rem;
+					}
+					&::-webkit-scrollbar-corner {
+						background: transparent;
+					}
+					&::-webkit-scrollbar-thumb {
+						background: rgb(136, 136, 136);
+						border-radius: 0.625rem;
+					}
+					&::-webkit-scrollbar-track {
+						background: transparent;
+					}
+				}
+			}
+		}
+
+		.invite-team-members-container {
+			display: flex;
+			width: 100%;
+			flex-direction: column;
+			gap: 12px;
+
+			.ant-input-group {
+				width: 100%;
+
+				.ant-input {
+					font-size: 12px;
+
+					height: 32px;
+					background: var(--Ink-300, #16181d);
+					border: 1px solid var(--bg-slate-400);
+					color: var(--bg-vanilla-400);
+				}
+
+				.ant-input-group-addon {
+					font-size: 11px;
+					height: 32px;
+					min-width: 80px;
+					background: var(--Ink-300, #16181d);
+					border: 1px solid var(--Greyscale-Slate-400, #1d212d);
+					border-left: 0px;
+					color: var(--bg-vanilla-400);
+				}
+			}
+		}
+
+		.question-label {
+			color: var(--bg-vanilla-100);
+			font-size: 13px;
+			font-style: normal;
+			font-weight: 500;
+			line-height: 20px;
+		}
+
+		.question-sub-label {
+			color: var(--bg-vanilla-400);
+			font-size: 11px;
+			font-style: normal;
+			font-weight: 400;
+			line-height: 16px;
+		}
+
+		.next-prev-container {
+			display: flex;
+			justify-content: space-between;
+			align-items: center;
+			gap: 10px;
+			margin-bottom: 24px;
+
+			.ant-btn {
+				flex: 1;
+			}
+		}
+
+		.form-group {
+			display: flex;
+			flex-direction: column;
+			align-items: flex-start;
+			gap: 8px;
+			align-self: stretch;
+		}
+
+		.slider-container {
+			width: 100%;
+
+			.ant-slider .ant-slider-mark {
+				font-size: 10px;
+			}
+		}
+
+		.do-later-container {
+			width: 100%;
+			display: flex;
+			justify-content: center;
+			align-items: center;
+			margin-top: 24px;
+
+			.do-later-button {
+				font-size: 12px;
+
+				display: flex;
+				justify-content: center;
+				align-items: center;
+				gap: 8px;
+			}
+		}
+
+		.question {
+			color: var(--bg-vanilla-100);
+			font-size: 14px;
+			font-style: normal;
+			font-weight: 500;
+			line-height: 20px;
+
+			display: flex;
+			align-items: center;
+			gap: 8px;
+		}
+
+		input[type='text'] {
+			width: 100%;
+			padding: 12px;
+			border-radius: 2px;
+			font-size: 14px;
+			height: 40px;
+			border: 1px solid var(--bg-slate-400);
+			background: var(--bg-ink-300);
+			color: var(--bg-vanilla-100);
+
+			&:focus-visible {
+				outline: none;
+			}
+		}
+
+		.radio-group,
+		.grid,
+		.tool-grid {
+			display: flex;
+			align-items: flex-start;
+			align-content: flex-start;
+			gap: 10px;
+			align-self: stretch;
+			flex-wrap: wrap;
+		}
+
+		.radio-button,
+		.grid-button,
+		.tool-button {
+			border-radius: 4px;
+			border: 1px solid var(--bg-slate-400);
+			background: var(--bg-ink-300);
+			padding: 12px;
+			color: var(--bg-vanilla-400);
+			font-size: 14px;
+			font-style: normal;
+			text-align: left;
+			font-weight: 400;
+			transition: background-color 0.3s ease;
+			min-width: 258px;
+			cursor: pointer;
+			box-sizing: border-box;
+		}
+
+		.radio-button.active,
+		.grid-button.active,
+		.tool-button.active,
+		.radio-button:hover,
+		.grid-button:hover,
+		.tool-button:hover {
+			border: 1px solid rgba(78, 116, 248, 0.4);
+			background: rgba(78, 116, 248, 0.2);
+		}
+
+		.two-column-grid {
+			width: 100%;
+			display: grid;
+			grid-template-columns: 1fr 1fr; /* Two equal columns */
+			gap: 10px;
+		}
+
+		.onboarding-questionaire-button,
+		.add-another-member-button,
+		.remove-team-member-button {
+			display: flex;
+			align-items: center;
+			justify-content: space-between;
+			border-radius: 2px;
+			border: 1px solid var(--bg-slate-400);
+			background: var(--bg-ink-300);
+			color: var(--bg-vanilla-400);
+			box-shadow: none;
+			font-size: 14px;
+			font-style: normal;
+			text-align: left;
+			font-weight: 400;
+			transition: background-color 0.3s ease;
+			cursor: pointer;
+			height: 40px;
+			box-sizing: border-box;
+
+			&:hover {
+				border: 1px solid rgba(78, 116, 248, 0.4);
+				background: rgba(78, 116, 248, 0.2);
+			}
+
+			&:focus-visible {
+				outline: none;
+			}
+
+			&.active {
+				border: 1px solid rgba(78, 116, 248, 0.4);
+				background: rgba(78, 116, 248, 0.2);
+			}
+		}
+
+		.add-another-member-button,
+		.remove-team-member-button {
+			font-size: 12px;
+			height: 32px;
+		}
+
+		.remove-team-member-button {
+			display: flex;
+			align-items: center;
+			justify-content: center;
+
+			border: 1px solid var(--bg-slate-400);
+			border-top-left-radius: 0px;
+			border-bottom-left-radius: 0px;
+			background-color: var(--bg-ink-300);
+
+			border-left: 0px;
+			border-top-left-radius: 0px;
+			border-bottom-left-radius: 0px;
+		}
+
+		.onboarding-questionaire-other-input {
+			.ant-input-group {
+				.ant-input {
+					border-top-right-radius: 0px !important;
+					border-bottom-right-radius: 0px !important;
+				}
+			}
+		}
+
+		.tool-grid {
+			grid-template-columns: repeat(4, 1fr);
+		}
+
+		.input-field {
+			flex: 0;
+			padding: 12px;
+			border: 1px solid var(--bg-slate-400);
+			background: var(--bg-ink-300);
+			color: var(--bg-vanilla-100);
+			border-radius: 4px;
+			font-size: 14px;
+			min-width: 258px;
+		}
+
+		.next-button {
+			display: flex;
+			height: 40px;
+			padding: 8px 12px 8px 16px;
+			justify-content: center;
+			align-items: center;
+			gap: 6px;
+			align-self: stretch;
+			border: 0px;
+			border-radius: 50px;
+			margin-top: 24px;
+			cursor: pointer;
+		}
+
+		.next-button.disabled {
+			opacity: 0.5;
+			cursor: not-allowed;
+			pointer-events: none;
+		}
+
+		.arrow {
+			font-size: 18px;
+			color: var(--bg-vanilla-100);
+		}
+	}
+
+	.onboarding-questionaire-footer {
+		width: 100%;
+		height: 60px;
+		padding: 12px 24px;
+		box-sizing: border-box;
+	}
+
+	.invite-team-members-add-another-member-container {
+		width: 100%;
+		display: flex;
+		justify-content: flex-end;
+		align-items: center;
+		margin-top: 12px;
+	}
+}
+
+.onboarding-questionaire-loading-container {
+	width: 100%;
+	display: flex;
+	height: 100vh;
+	max-width: 600px;
+	justify-content: center;
+	align-items: center;
+	margin: 0 auto;
+}
+
+.lightMode {
+	.onboarding-questionaire-container {
+		.onboarding-questionaire-content {
+			.questions-container {
+				color: var(--bg-slate-300);
+			}
+
+			.title {
+				color: var(--bg-slate-300) !important;
+			}
+
+			.sub-title {
+				color: var(--bg-slate-400) !important;
+			}
+
+			.questions-form {
+				width: 100%;
+				display: flex;
+				min-height: 420px;
+				padding: 20px 24px 24px 24px;
+				flex-direction: column;
+				align-items: center;
+				gap: 24px;
+				border-radius: 4px;
+				border: 1px solid var(--bg-vanilla-300);
+				background: var(--bg-vanilla-100);
+
+				.ant-form-item {
+					margin-bottom: 0px !important;
+
+					.ant-form-item-label {
+						label {
+							color: var(--bg-slate-300) !important;
+							font-size: 13px;
+							font-weight: 500;
+							line-height: 20px;
+						}
+					}
+				}
+
+				&.invite-team-members-form {
+					.invite-team-members-container {
+						max-height: 260px;
+						overflow-y: auto;
+
+						&::-webkit-scrollbar {
+							width: 0.1rem;
+						}
+						&::-webkit-scrollbar-corner {
+							background: transparent;
+						}
+						&::-webkit-scrollbar-thumb {
+							background: rgb(136, 136, 136);
+							border-radius: 0.625rem;
+						}
+						&::-webkit-scrollbar-track {
+							background: transparent;
+						}
+					}
+				}
+			}
+
+			.invite-team-members-container {
+				.ant-input-group {
+					.ant-input {
+						background: var(--bg-vanilla-100);
+						border: 1px solid var(--bg-vanilla-300);
+						color: var(--bg-slate-300);
+					}
+
+					.ant-input-group-addon {
+						font-size: 11px;
+						height: 32px;
+						min-width: 80px;
+						background: var(--bg-vanilla-100);
+						border: 1px solid var(--bg-vanilla-300);
+						border-left: 0px;
+						color: var(--bg-slate-300);
+					}
+				}
+			}
+
+			.question-label {
+				color: var(--bg-slate-300);
+			}
+
+			.question-sub-label {
+				color: var(--bg-slate-400);
+			}
+
+			.question {
+				color: var(--bg-slate-300);
+			}
+
+			input[type='text'] {
+				border: 1px solid var(--bg-vanilla-300);
+				background: var(--bg-vanilla-100);
+				color: var(--text-ink-300);
+			}
+
+			.radio-button,
+			.grid-button,
+			.tool-button {
+				border-radius: 4px;
+				border: 1px solid var(--bg-vanilla-300);
+				background: var(--bg-vanilla-100);
+				padding: 12px;
+				color: var(--bg-slate-300);
+				font-size: 14px;
+				font-style: normal;
+				text-align: left;
+				font-weight: 400;
+				transition: background-color 0.3s ease;
+				min-width: 258px;
+				cursor: pointer;
+				box-sizing: border-box;
+			}
+
+			.radio-button.active,
+			.grid-button.active,
+			.tool-button.active,
+			.radio-button:hover,
+			.grid-button:hover,
+			.tool-button:hover {
+				border: 1px solid rgba(78, 116, 248, 0.4);
+				background: rgba(78, 116, 248, 0.2);
+			}
+
+			.onboarding-questionaire-button,
+			.add-another-member-button,
+			.remove-team-member-button {
+				display: flex;
+				align-items: center;
+				justify-content: space-between;
+				border-radius: 2px;
+				border: 1px solid var(--bg-vanilla-300);
+				background: var(--bg-vanilla-100);
+				color: var(--bg-ink-300);
+				box-shadow: none;
+				font-size: 14px;
+				font-style: normal;
+				text-align: left;
+				font-weight: 400;
+				transition: background-color 0.3s ease;
+				cursor: pointer;
+				height: 40px;
+				box-sizing: border-box;
+
+				&:hover {
+					border: 1px solid rgba(78, 116, 248, 0.4);
+					background: rgba(78, 116, 248, 0.2);
+				}
+
+				&:focus-visible {
+					outline: none;
+				}
+
+				&.active {
+					border: 1px solid rgba(78, 116, 248, 0.4);
+					background: rgba(78, 116, 248, 0.2);
+				}
+			}
+
+			.remove-team-member-button {
+				display: flex;
+				align-items: center;
+				justify-content: center;
+
+				border: 1px solid var(--bg-vanilla-300);
+				border-top-left-radius: 0px;
+				border-bottom-left-radius: 0px;
+				background-color: var(--bg-vanilla-100);
+
+				border-left: 0px;
+				border-top-left-radius: 0px;
+				border-bottom-left-radius: 0px;
+			}
+
+			.input-field {
+				border: 1px solid var(--bg-vanilla-300);
+				background: var(--bg-vanilla-100);
+				color: var(--text-ink-300);
+			}
+
+			.arrow {
+				color: var(--bg-slate-300);
+			}
+		}
+	}
+}

frontend/src/container/OnboardingQuestionaire/OptimiseSignozNeeds/OptimiseSignozNeeds.tsx

@@ -0,0 +1,323 @@
+import { Button, Slider, Typography } from 'antd';
+import logEvent from 'api/common/logEvent';
+import { ArrowLeft, ArrowRight, Loader2, Minus } from 'lucide-react';
+import { useEffect, useState } from 'react';
+
+export interface OptimiseSignozDetails {
+	logsPerDay: number;
+	hostsPerDay: number;
+	services: number;
+}
+
+// Define exponential range
+const logsMin = 1; // Set to your minimum value in the exponential range
+const logsMax = 10000; // Set to your maximum value in the exponential range
+
+const hostsMin = 1;
+const hostsMax = 10000;
+
+const servicesMin = 1;
+const servicesMax = 5000;
+
+// Function to convert linear slider value to exponential scale
+const linearToExponential = (
+	value: number,
+	min: number,
+	max: number,
+): number => {
+	const expMin = Math.log10(min);
+	const expMax = Math.log10(max);
+	const expValue = 10 ** (expMin + ((expMax - expMin) * value) / 100);
+	return Math.round(expValue);
+};
+
+const exponentialToLinear = (
+	expValue: number,
+	min: number,
+	max: number,
+): number => {
+	const expMin = Math.log10(min);
+	const expMax = Math.log10(max);
+	const linearValue =
+		((Math.log10(expValue) - expMin) / (expMax - expMin)) * 100;
+	return Math.round(linearValue); // Round to get a whole number within the 0-100 range
+};
+
+interface OptimiseSignozNeedsProps {
+	optimiseSignozDetails: OptimiseSignozDetails;
+	setOptimiseSignozDetails: (details: OptimiseSignozDetails) => void;
+	onNext: () => void;
+	onBack: () => void;
+	onWillDoLater: () => void;
+	isUpdatingProfile: boolean;
+	isNextDisabled: boolean;
+}
+
+const marks = {
+	0: `${linearToExponential(0, logsMin, logsMax).toLocaleString()} GB`,
+	25: `${linearToExponential(25, logsMin, logsMax).toLocaleString()} GB`,
+	50: `${linearToExponential(50, logsMin, logsMax).toLocaleString()} GB`,
+	75: `${linearToExponential(75, logsMin, logsMax).toLocaleString()} GB`,
+	100: `${linearToExponential(100, logsMin, logsMax).toLocaleString()} GB`,
+};
+
+const hostMarks = {
+	0: `${linearToExponential(0, hostsMin, hostsMax).toLocaleString()}`,
+	25: `${linearToExponential(25, hostsMin, hostsMax).toLocaleString()}`,
+	50: `${linearToExponential(50, hostsMin, hostsMax).toLocaleString()}`,
+	75: `${linearToExponential(75, hostsMin, hostsMax).toLocaleString()}`,
+	100: `${linearToExponential(100, hostsMin, hostsMax).toLocaleString()}`,
+};
+
+const serviceMarks = {
+	0: `${linearToExponential(0, servicesMin, servicesMax).toLocaleString()}`,
+	25: `${linearToExponential(25, servicesMin, servicesMax).toLocaleString()}`,
+	50: `${linearToExponential(50, servicesMin, servicesMax).toLocaleString()}`,
+	75: `${linearToExponential(75, servicesMin, servicesMax).toLocaleString()}`,
+	100: `${linearToExponential(100, servicesMin, servicesMax).toLocaleString()}`,
+};
+
+function OptimiseSignozNeeds({
+	isUpdatingProfile,
+	optimiseSignozDetails,
+	setOptimiseSignozDetails,
+	onNext,
+	onBack,
+	onWillDoLater,
+	isNextDisabled,
+}: OptimiseSignozNeedsProps): JSX.Element {
+	const [logsPerDay, setLogsPerDay] = useState<number>(
+		optimiseSignozDetails?.logsPerDay || 0,
+	);
+	const [hostsPerDay, setHostsPerDay] = useState<number>(
+		optimiseSignozDetails?.hostsPerDay || 0,
+	);
+	const [services, setServices] = useState<number>(
+		optimiseSignozDetails?.services || 0,
+	);
+
+	// Internal state for the linear slider
+	const [sliderValues, setSliderValues] = useState({
+		logsPerDay: 0,
+		hostsPerDay: 0,
+		services: 0,
+	});
+
+	useEffect(() => {
+		setSliderValues({
+			logsPerDay: exponentialToLinear(logsPerDay, logsMin, logsMax),
+			hostsPerDay: exponentialToLinear(hostsPerDay, hostsMin, hostsMax),
+			services: exponentialToLinear(services, servicesMin, servicesMax),
+		});
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, []);
+
+	useEffect(() => {
+		setOptimiseSignozDetails({
+			logsPerDay,
+			hostsPerDay,
+			services,
+		});
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [services, hostsPerDay, logsPerDay]);
+
+	const handleOnNext = (): void => {
+		logEvent('Org Onboarding: Answered', {
+			logsPerDay,
+			hostsPerDay,
+			services,
+		});
+
+		onNext();
+	};
+
+	const handleOnBack = (): void => {
+		onBack();
+	};
+
+	const handleWillDoLater = (): void => {
+		setOptimiseSignozDetails({
+			logsPerDay: 0,
+			hostsPerDay: 0,
+			services: 0,
+		});
+
+		onWillDoLater();
+
+		logEvent('Org Onboarding: Clicked Do Later', {
+			currentPageID: 3,
+		});
+	};
+
+	const handleSliderChange = (key: string, value: number): void => {
+		setSliderValues({
+			...sliderValues,
+			[key]: value,
+		});
+
+		switch (key) {
+			case 'logsPerDay':
+				setLogsPerDay(linearToExponential(value, logsMin, logsMax));
+				break;
+			case 'hostsPerDay':
+				setHostsPerDay(linearToExponential(value, hostsMin, hostsMax));
+				break;
+			case 'services':
+				setServices(linearToExponential(value, servicesMin, servicesMax));
+				break;
+			default:
+				break;
+		}
+	};
+
+	// Calculate the exponential value based on the current slider position
+	const logsPerDayValue = linearToExponential(
+		sliderValues.logsPerDay,
+		logsMin,
+		logsMax,
+	);
+	const hostsPerDayValue = linearToExponential(
+		sliderValues.hostsPerDay,
+		hostsMin,
+		hostsMax,
+	);
+	const servicesValue = linearToExponential(
+		sliderValues.services,
+		servicesMin,
+		servicesMax,
+	);
+
+	return (
+		<div className="questions-container">
+			<Typography.Title level={3} className="title">
+				Optimize SigNoz for Your Needs
+			</Typography.Title>
+			<Typography.Paragraph className="sub-title">
+				Give us a quick sense of your scale so SigNoz can keep up!
+			</Typography.Paragraph>
+
+			<div className="questions-form-container">
+				<div className="questions-form">
+					<Typography.Paragraph className="question">
+						What does your scale approximately look like?
+					</Typography.Paragraph>
+
+					<div className="form-group">
+						<label className="question" htmlFor="organisationName">
+							Logs / Day
+						</label>
+						<div className="slider-container">
+							<div>
+								<Slider
+									min={0}
+									max={100}
+									value={sliderValues.logsPerDay}
+									marks={marks}
+									onChange={(value: number): void =>
+										handleSliderChange('logsPerDay', value)
+									}
+									styles={{
+										track: {
+											background: '#4E74F8',
+										},
+									}}
+									tooltip={{
+										formatter: (): string => `${logsPerDayValue.toLocaleString()} GB`, // Show whole number
+									}}
+								/>
+							</div>
+						</div>
+					</div>
+
+					<div className="form-group">
+						<label className="question" htmlFor="organisationName">
+							Metrics <Minus size={14} /> Number of Hosts
+						</label>
+						<div className="slider-container">
+							<div>
+								<Slider
+									min={0}
+									max={100}
+									value={sliderValues.hostsPerDay}
+									marks={hostMarks}
+									onChange={(value: number): void =>
+										handleSliderChange('hostsPerDay', value)
+									}
+									styles={{
+										track: {
+											background: '#4E74F8',
+										},
+									}}
+									tooltip={{
+										formatter: (): string => `${hostsPerDayValue.toLocaleString()}`, // Show whole number
+									}}
+								/>
+							</div>
+						</div>
+					</div>
+
+					<div className="form-group">
+						<label className="question" htmlFor="organisationName">
+							Number of services
+						</label>
+						<div className="slider-container">
+							<div>
+								<Slider
+									min={0}
+									max={100}
+									value={sliderValues.services}
+									marks={serviceMarks}
+									onChange={(value: number): void =>
+										handleSliderChange('services', value)
+									}
+									styles={{
+										track: {
+											background: '#4E74F8',
+										},
+									}}
+									tooltip={{
+										formatter: (): string => `${servicesValue.toLocaleString()}`, // Show whole number
+									}}
+								/>
+							</div>
+						</div>
+					</div>
+				</div>
+
+				<div className="next-prev-container">
+					<Button
+						type="default"
+						className="next-button"
+						onClick={handleOnBack}
+						disabled={isUpdatingProfile}
+					>
+						<ArrowLeft size={14} />
+						Back
+					</Button>
+
+					<Button
+						type="primary"
+						className="next-button"
+						onClick={handleOnNext}
+						disabled={isUpdatingProfile || isNextDisabled}
+					>
+						Next{' '}
+						{isUpdatingProfile ? (
+							<Loader2 className="animate-spin" />
+						) : (
+							<ArrowRight size={14} />
+						)}
+					</Button>
+				</div>
+
+				<div className="do-later-container">
+					<Button type="link" onClick={handleWillDoLater}>
+						I&apos;ll do this later
+					</Button>
+				</div>
+			</div>
+		</div>
+	);
+}
+
+export default OptimiseSignozNeeds;

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

@@ -0,0 +1,376 @@
+/* eslint-disable sonarjs/cognitive-complexity */
+import '../OnboardingQuestionaire.styles.scss';
+
+import { Color } from '@signozhq/design-tokens';
+import { Button, Input, Typography } from 'antd';
+import logEvent from 'api/common/logEvent';
+import editOrg from 'api/user/editOrg';
+import { useNotifications } from 'hooks/useNotifications';
+import { ArrowRight, CheckCircle, Loader2 } from 'lucide-react';
+import { Dispatch, useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { useDispatch, useSelector } from 'react-redux';
+import { AppState } from 'store/reducers';
+import AppActions from 'types/actions';
+import { UPDATE_ORG_NAME } from 'types/actions/app';
+import AppReducer from 'types/reducer/app';
+
+export interface OrgData {
+	id: string;
+	isAnonymous: boolean;
+	name: string;
+}
+
+export interface OrgDetails {
+	organisationName: string;
+	usesObservability: boolean | null;
+	observabilityTool: string | null;
+	otherTool: string | null;
+	familiarity: string | null;
+}
+
+interface OrgQuestionsProps {
+	currentOrgData: OrgData | null;
+	orgDetails: OrgDetails;
+	onNext: (details: OrgDetails) => void;
+}
+
+const observabilityTools = {
+	AWSCloudwatch: 'AWS Cloudwatch',
+	DataDog: 'DataDog',
+	NewRelic: 'New Relic',
+	GrafanaPrometheus: 'Grafana / Prometheus',
+	AzureAppMonitor: 'Azure App Monitor',
+	GCPNativeO11yTools: 'GCP-native o11y tools',
+	Honeycomb: 'Honeycomb',
+};
+
+const o11yFamiliarityOptions: Record<string, string> = {
+	beginner: 'Beginner',
+	intermediate: 'Intermediate',
+	expert: 'Expert',
+	notFamiliar: "I'm not familiar with it",
+};
+
+function OrgQuestions({
+	currentOrgData,
+	orgDetails,
+	onNext,
+}: OrgQuestionsProps): JSX.Element {
+	const { user } = useSelector<AppState, AppReducer>((state) => state.app);
+	const { notifications } = useNotifications();
+	const dispatch = useDispatch<Dispatch<AppActions>>();
+
+	const { t } = useTranslation(['organizationsettings', 'common']);
+
+	const [organisationName, setOrganisationName] = useState<string>(
+		orgDetails?.organisationName || '',
+	);
+	const [usesObservability, setUsesObservability] = useState<boolean | null>(
+		orgDetails?.usesObservability || null,
+	);
+	const [observabilityTool, setObservabilityTool] = useState<string | null>(
+		orgDetails?.observabilityTool || null,
+	);
+	const [otherTool, setOtherTool] = useState<string>(
+		orgDetails?.otherTool || '',
+	);
+	const [familiarity, setFamiliarity] = useState<string | null>(
+		orgDetails?.familiarity || null,
+	);
+	const [isNextDisabled, setIsNextDisabled] = useState<boolean>(true);
+
+	useEffect(() => {
+		setOrganisationName(orgDetails.organisationName);
+	}, [orgDetails.organisationName]);
+
+	const [isLoading, setIsLoading] = useState<boolean>(false);
+
+	const handleOrgNameUpdate = async (): Promise<void> => {
+		/* Early bailout if orgData is not set or if the organisation name is not set or if the organisation name is empty or if the organisation name is the same as the one in the orgData */
+		if (
+			!currentOrgData ||
+			!organisationName ||
+			organisationName === '' ||
+			orgDetails.organisationName === organisationName
+		) {
+			logEvent('Org Onboarding: Answered', {
+				usesObservability,
+				observabilityTool,
+				otherTool,
+				familiarity,
+			});
+
+			onNext({
+				organisationName,
+				usesObservability,
+				observabilityTool,
+				otherTool,
+				familiarity,
+			});
+
+			return;
+		}
+
+		try {
+			setIsLoading(true);
+			const { statusCode, error } = await editOrg({
+				isAnonymous: currentOrgData.isAnonymous,
+				name: organisationName,
+				orgId: currentOrgData.id,
+			});
+			if (statusCode === 200) {
+				dispatch({
+					type: UPDATE_ORG_NAME,
+					payload: {
+						orgId: currentOrgData?.id,
+						name: orgDetails.organisationName,
+					},
+				});
+
+				logEvent('Org Onboarding: Org Name Updated', {
+					organisationName: orgDetails.organisationName,
+				});
+
+				logEvent('Org Onboarding: Answered', {
+					usesObservability,
+					observabilityTool,
+					otherTool,
+					familiarity,
+				});
+
+				onNext({
+					organisationName,
+					usesObservability,
+					observabilityTool,
+					otherTool,
+					familiarity,
+				});
+			} else {
+				logEvent('Org Onboarding: Org Name Update Failed', {
+					organisationName: orgDetails.organisationName,
+				});
+
+				notifications.error({
+					message:
+						error ||
+						t('something_went_wrong', {
+							ns: 'common',
+						}),
+				});
+			}
+			setIsLoading(false);
+		} catch (error) {
+			setIsLoading(false);
+			notifications.error({
+				message: t('something_went_wrong', {
+					ns: 'common',
+				}),
+			});
+		}
+	};
+
+	const isValidUsesObservability = (): boolean => {
+		if (usesObservability === null) {
+			return false;
+		}
+
+		if (usesObservability && (!observabilityTool || observabilityTool === '')) {
+			return false;
+		}
+
+		// eslint-disable-next-line sonarjs/prefer-single-boolean-return
+		if (usesObservability && observabilityTool === 'Others' && otherTool === '') {
+			return false;
+		}
+
+		return true;
+	};
+
+	useEffect(() => {
+		const isValidObservability = isValidUsesObservability();
+
+		if (organisationName !== '' && familiarity !== null && isValidObservability) {
+			setIsNextDisabled(false);
+		} else {
+			setIsNextDisabled(true);
+		}
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [
+		organisationName,
+		usesObservability,
+		familiarity,
+		observabilityTool,
+		otherTool,
+	]);
+
+	const handleOnNext = (): void => {
+		handleOrgNameUpdate();
+	};
+
+	return (
+		<div className="questions-container">
+			<Typography.Title level={3} className="title">
+				Welcome, {user?.name}!
+			</Typography.Title>
+			<Typography.Paragraph className="sub-title">
+				We&apos;ll help you get the most out of SigNoz, whether you&apos;re new to
+				observability or a seasoned pro.
+			</Typography.Paragraph>
+
+			<div className="questions-form-container">
+				<div className="questions-form">
+					<div className="form-group">
+						<label className="question" htmlFor="organisationName">
+							Your Organisation Name
+						</label>
+						<input
+							type="text"
+							name="organisationName"
+							id="organisationName"
+							placeholder="For eg. Simpsonville..."
+							autoComplete="off"
+							value={organisationName}
+							onChange={(e): void => setOrganisationName(e.target.value)}
+						/>
+					</div>
+
+					<div className="form-group">
+						<label className="question" htmlFor="usesObservability">
+							Do you currently use any observability/monitoring tool?
+						</label>
+
+						<div className="two-column-grid">
+							<Button
+								type="primary"
+								name="usesObservability"
+								className={`onboarding-questionaire-button ${
+									usesObservability === true ? 'active' : ''
+								}`}
+								onClick={(): void => {
+									setUsesObservability(true);
+								}}
+							>
+								Yes{' '}
+								{usesObservability === true && (
+									<CheckCircle size={12} color={Color.BG_FOREST_500} />
+								)}
+							</Button>
+							<Button
+								type="primary"
+								className={`onboarding-questionaire-button ${
+									usesObservability === false ? 'active' : ''
+								}`}
+								onClick={(): void => {
+									setUsesObservability(false);
+									setObservabilityTool(null);
+									setOtherTool('');
+								}}
+							>
+								No{' '}
+								{usesObservability === false && (
+									<CheckCircle size={12} color={Color.BG_FOREST_500} />
+								)}
+							</Button>
+						</div>
+					</div>
+
+					{usesObservability && (
+						<div className="form-group">
+							<label className="question" htmlFor="observabilityTool">
+								Which observability tool do you currently use?
+							</label>
+							<div className="two-column-grid">
+								{Object.keys(observabilityTools).map((tool) => (
+									<Button
+										key={tool}
+										type="primary"
+										className={`onboarding-questionaire-button ${
+											observabilityTool === tool ? 'active' : ''
+										}`}
+										onClick={(): void => setObservabilityTool(tool)}
+									>
+										{observabilityTools[tool as keyof typeof observabilityTools]}
+
+										{observabilityTool === tool && (
+											<CheckCircle size={12} color={Color.BG_FOREST_500} />
+										)}
+									</Button>
+								))}
+
+								{observabilityTool === 'Others' ? (
+									<Input
+										type="text"
+										className="onboarding-questionaire-other-input"
+										placeholder="Please specify the tool"
+										value={otherTool || ''}
+										autoFocus
+										addonAfter={
+											otherTool && otherTool !== '' ? (
+												<CheckCircle size={12} color={Color.BG_FOREST_500} />
+											) : (
+												''
+											)
+										}
+										onChange={(e): void => setOtherTool(e.target.value)}
+									/>
+								) : (
+									<button
+										type="button"
+										className={`onboarding-questionaire-button ${
+											observabilityTool === 'Others' ? 'active' : ''
+										}`}
+										onClick={(): void => setObservabilityTool('Others')}
+									>
+										Others
+									</button>
+								)}
+							</div>
+						</div>
+					)}
+
+					<div className="form-group">
+						<div className="question">
+							Are you familiar with setting up observability (o11y)?
+						</div>
+						<div className="two-column-grid">
+							{Object.keys(o11yFamiliarityOptions).map((option: string) => (
+								<Button
+									key={option}
+									type="primary"
+									className={`onboarding-questionaire-button ${
+										familiarity === option ? 'active' : ''
+									}`}
+									onClick={(): void => setFamiliarity(option)}
+								>
+									{o11yFamiliarityOptions[option]}
+									{familiarity === option && (
+										<CheckCircle size={12} color={Color.BG_FOREST_500} />
+									)}
+								</Button>
+							))}
+						</div>
+					</div>
+				</div>
+
+				<div className="next-prev-container">
+					<Button
+						type="primary"
+						className={`next-button ${isNextDisabled ? 'disabled' : ''}`}
+						onClick={handleOnNext}
+						disabled={isNextDisabled}
+					>
+						Next
+						{isLoading ? (
+							<Loader2 className="animate-spin" />
+						) : (
+							<ArrowRight size={14} />
+						)}
+					</Button>
+				</div>
+			</div>
+		</div>
+	);
+}
+
+export default OrgQuestions;

frontend/src/container/OnboardingQuestionaire/index.tsx

@@ -0,0 +1,295 @@
+import './OnboardingQuestionaire.styles.scss';
+
+import { NotificationInstance } from 'antd/es/notification/interface';
+import logEvent from 'api/common/logEvent';
+import updateProfileAPI from 'api/onboarding/updateProfile';
+import getAllOrgPreferences from 'api/preferences/getAllOrgPreferences';
+import updateOrgPreferenceAPI from 'api/preferences/updateOrgPreference';
+import { AxiosError } from 'axios';
+import { SOMETHING_WENT_WRONG } from 'constants/api';
+import ROUTES from 'constants/routes';
+import { InviteTeamMembersProps } from 'container/OrganizationSettings/PendingInvitesContainer';
+import { useNotifications } from 'hooks/useNotifications';
+import history from 'lib/history';
+import { useEffect, useState } from 'react';
+import { useMutation, useQuery } from 'react-query';
+import { useDispatch, useSelector } from 'react-redux';
+import { AppState } from 'store/reducers';
+import {
+	UPDATE_IS_FETCHING_ORG_PREFERENCES,
+	UPDATE_ORG_PREFERENCES,
+} from 'types/actions/app';
+import AppReducer from 'types/reducer/app';
+
+import {
+	AboutSigNozQuestions,
+	SignozDetails,
+} from './AboutSigNozQuestions/AboutSigNozQuestions';
+import InviteTeamMembers from './InviteTeamMembers/InviteTeamMembers';
+import { OnboardingHeader } from './OnboardingHeader/OnboardingHeader';
+import OptimiseSignozNeeds, {
+	OptimiseSignozDetails,
+} from './OptimiseSignozNeeds/OptimiseSignozNeeds';
+import OrgQuestions, { OrgData, OrgDetails } from './OrgQuestions/OrgQuestions';
+
+export const showErrorNotification = (
+	notifications: NotificationInstance,
+	err: Error,
+): void => {
+	notifications.error({
+		message: err.message || SOMETHING_WENT_WRONG,
+	});
+};
+
+const INITIAL_ORG_DETAILS: OrgDetails = {
+	organisationName: '',
+	usesObservability: true,
+	observabilityTool: '',
+	otherTool: '',
+	familiarity: '',
+};
+
+const INITIAL_SIGNOZ_DETAILS: SignozDetails = {
+	hearAboutSignoz: '',
+	interestInSignoz: '',
+	otherInterestInSignoz: '',
+	otherAboutSignoz: '',
+};
+
+const INITIAL_OPTIMISE_SIGNOZ_DETAILS: OptimiseSignozDetails = {
+	logsPerDay: 0,
+	hostsPerDay: 0,
+	services: 0,
+};
+
+const BACK_BUTTON_EVENT_NAME = 'Org Onboarding: Back Button Clicked';
+const NEXT_BUTTON_EVENT_NAME = 'Org Onboarding: Next Button Clicked';
+const ONBOARDING_COMPLETE_EVENT_NAME = 'Org Onboarding: Complete';
+
+function OnboardingQuestionaire(): JSX.Element {
+	const { notifications } = useNotifications();
+	const { org } = useSelector<AppState, AppReducer>((state) => state.app);
+	const dispatch = useDispatch();
+	const [currentStep, setCurrentStep] = useState<number>(1);
+	const [orgDetails, setOrgDetails] = useState<OrgDetails>(INITIAL_ORG_DETAILS);
+	const [signozDetails, setSignozDetails] = useState<SignozDetails>(
+		INITIAL_SIGNOZ_DETAILS,
+	);
+
+	const [
+		optimiseSignozDetails,
+		setOptimiseSignozDetails,
+	] = useState<OptimiseSignozDetails>(INITIAL_OPTIMISE_SIGNOZ_DETAILS);
+	const [teamMembers, setTeamMembers] = useState<
+		InviteTeamMembersProps[] | null
+	>(null);
+
+	const [currentOrgData, setCurrentOrgData] = useState<OrgData | null>(null);
+
+	const [
+		updatingOrgOnboardingStatus,
+		setUpdatingOrgOnboardingStatus,
+	] = useState<boolean>(false);
+
+	useEffect(() => {
+		if (org) {
+			setCurrentOrgData(org[0]);
+
+			setOrgDetails({
+				...orgDetails,
+				organisationName: org[0].name,
+			});
+		}
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [org]);
+
+	useEffect(() => {
+		logEvent('Org Onboarding: Started', {
+			org_id: org?.[0]?.id,
+		});
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, []);
+
+	const { refetch: refetchOrgPreferences } = useQuery({
+		queryFn: () => getAllOrgPreferences(),
+		queryKey: ['getOrgPreferences'],
+		enabled: false,
+		refetchOnWindowFocus: false,
+		onSuccess: (response) => {
+			dispatch({
+				type: UPDATE_IS_FETCHING_ORG_PREFERENCES,
+				payload: {
+					isFetchingOrgPreferences: false,
+				},
+			});
+
+			dispatch({
+				type: UPDATE_ORG_PREFERENCES,
+				payload: {
+					orgPreferences: response.payload?.data || null,
+				},
+			});
+
+			setUpdatingOrgOnboardingStatus(false);
+
+			logEvent('Org Onboarding: Redirecting to Get Started', {});
+
+			history.push(ROUTES.GET_STARTED);
+		},
+		onError: () => {
+			setUpdatingOrgOnboardingStatus(false);
+		},
+	});
+
+	const isNextDisabled =
+		optimiseSignozDetails.logsPerDay === 0 &&
+		optimiseSignozDetails.hostsPerDay === 0 &&
+		optimiseSignozDetails.services === 0;
+
+	const { mutate: updateProfile, isLoading: isUpdatingProfile } = useMutation(
+		updateProfileAPI,
+		{
+			onSuccess: () => {
+				setCurrentStep(4);
+			},
+			onError: (error) => {
+				showErrorNotification(notifications, error as AxiosError);
+			},
+		},
+	);
+
+	const { mutate: updateOrgPreference } = useMutation(updateOrgPreferenceAPI, {
+		onSuccess: () => {
+			refetchOrgPreferences();
+		},
+		onError: (error) => {
+			showErrorNotification(notifications, error as AxiosError);
+
+			setUpdatingOrgOnboardingStatus(false);
+		},
+	});
+
+	const handleUpdateProfile = (): void => {
+		logEvent(NEXT_BUTTON_EVENT_NAME, {
+			currentPageID: 3,
+			nextPageID: 4,
+		});
+
+		updateProfile({
+			familiarity_with_observability: orgDetails?.familiarity as string,
+			has_existing_observability_tool: orgDetails?.usesObservability as boolean,
+			existing_observability_tool:
+				orgDetails?.observabilityTool === 'Others'
+					? (orgDetails?.otherTool as string)
+					: (orgDetails?.observabilityTool as string),
+
+			reasons_for_interest_in_signoz:
+				signozDetails?.interestInSignoz === 'Others'
+					? (signozDetails?.otherInterestInSignoz as string)
+					: (signozDetails?.interestInSignoz as string),
+			where_did_you_hear_about_signoz:
+				signozDetails?.hearAboutSignoz === 'Others'
+					? (signozDetails?.otherAboutSignoz as string)
+					: (signozDetails?.hearAboutSignoz as string),
+
+			logs_scale_per_day_in_gb: optimiseSignozDetails?.logsPerDay as number,
+			number_of_hosts: optimiseSignozDetails?.hostsPerDay as number,
+			number_of_services: optimiseSignozDetails?.services as number,
+		});
+	};
+
+	const handleOnboardingComplete = (): void => {
+		logEvent(ONBOARDING_COMPLETE_EVENT_NAME, {
+			currentPageID: 4,
+		});
+
+		setUpdatingOrgOnboardingStatus(true);
+		updateOrgPreference({
+			preferenceID: 'ORG_ONBOARDING',
+			value: true,
+		});
+	};
+
+	return (
+		<div className="onboarding-questionaire-container">
+			<div className="onboarding-questionaire-header">
+				<OnboardingHeader />
+			</div>
+
+			<div className="onboarding-questionaire-content">
+				{currentStep === 1 && (
+					<OrgQuestions
+						currentOrgData={currentOrgData}
+						orgDetails={orgDetails}
+						onNext={(orgDetails: OrgDetails): void => {
+							logEvent(NEXT_BUTTON_EVENT_NAME, {
+								currentPageID: 1,
+								nextPageID: 2,
+							});
+
+							setOrgDetails(orgDetails);
+							setCurrentStep(2);
+						}}
+					/>
+				)}
+
+				{currentStep === 2 && (
+					<AboutSigNozQuestions
+						signozDetails={signozDetails}
+						setSignozDetails={setSignozDetails}
+						onBack={(): void => {
+							logEvent(BACK_BUTTON_EVENT_NAME, {
+								currentPageID: 2,
+								prevPageID: 1,
+							});
+							setCurrentStep(1);
+						}}
+						onNext={(): void => {
+							logEvent(NEXT_BUTTON_EVENT_NAME, {
+								currentPageID: 2,
+								nextPageID: 3,
+							});
+							setCurrentStep(3);
+						}}
+					/>
+				)}
+
+				{currentStep === 3 && (
+					<OptimiseSignozNeeds
+						isNextDisabled={isNextDisabled}
+						isUpdatingProfile={isUpdatingProfile}
+						optimiseSignozDetails={optimiseSignozDetails}
+						setOptimiseSignozDetails={setOptimiseSignozDetails}
+						onBack={(): void => {
+							logEvent(BACK_BUTTON_EVENT_NAME, {
+								currentPageID: 3,
+								prevPageID: 2,
+							});
+							setCurrentStep(2);
+						}}
+						onNext={handleUpdateProfile}
+						onWillDoLater={(): void => setCurrentStep(4)}
+					/>
+				)}
+
+				{currentStep === 4 && (
+					<InviteTeamMembers
+						isLoading={updatingOrgOnboardingStatus}
+						teamMembers={teamMembers}
+						setTeamMembers={setTeamMembers}
+						onBack={(): void => {
+							logEvent(BACK_BUTTON_EVENT_NAME, {
+								currentPageID: 4,
+								prevPageID: 3,
+							});
+							setCurrentStep(3);
+						}}
+						onNext={handleOnboardingComplete}
+					/>
+				)}
+			</div>
+		</div>
+	);
+}
+
+export default OnboardingQuestionaire;

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

@@ -236,7 +236,9 @@ function PendingInvitesContainer(): JSX.Element {
 export interface InviteTeamMembersProps {
 	email: string;
 	name: string;
-	role: ROLES;
+	role: string;
+	id: string;
+	frontendBaseUrl: string;
 }
 
 interface DataProps {

frontend/src/container/QueryBuilder/components/QueryFunctions/QueryFunctions.tsx

@@ -13,6 +13,7 @@ import {
 import { DataSource, QueryFunctionsTypes } from 'types/common/queryBuilder';
 
 import Function from './Function';
+import { toFloat64 } from './utils';
 
 const defaultMetricFunctionStruct: QueryFunctionProps = {
 	name: QueryFunctionsTypes.CUTOFF_MIN,
@@ -158,7 +159,13 @@ export default function QueryFunctions({
 		const updateFunctions = cloneDeep(functions);
 
 		if (updateFunctions && updateFunctions.length > 0 && updateFunctions[index]) {
-			updateFunctions[index].args = [value];
+			updateFunctions[index].args = [
+				// timeShift expects a float64 value, so we convert the string to a number
+				// For other functions, we keep the value as a string
+				updateFunctions[index].name === QueryFunctionsTypes.TIME_SHIFT
+					? toFloat64(value)
+					: value,
+			];
 			setFunctions(updateFunctions);
 			onChange(updateFunctions);
 		}

frontend/src/container/QueryBuilder/components/QueryFunctions/utils.ts

@@ -0,0 +1,7 @@
+export const toFloat64 = (value: string): number => {
+	const parsed = parseFloat(value);
+	if (!Number.isFinite(parsed)) {
+		console.error(`Invalid value for timeshift. value: ${value}`);
+	}
+	return parsed;
+};

frontend/src/container/QueryBuilder/filters/AggregatorFilter/AggregatorFilter.tsx

@@ -81,8 +81,10 @@ export const AggregatorFilter = memo(function AggregatorFilter({
 										prefix: item.type || '',
 										condition: !item.isColumn,
 									}),
+									!item.isColumn && item.type ? item.type : '',
 								)}
 								dataType={item.dataType}
+								type={item.type || ''}
 							/>
 						),
 						value: `${item.key}${selectValueDivider}${createIdFromObjectFields(
@@ -187,6 +189,9 @@ export const AggregatorFilter = memo(function AggregatorFilter({
 			prefix: query.aggregateAttribute.type || '',
 			condition: !query.aggregateAttribute.isColumn,
 		}),
+		!query.aggregateAttribute.isColumn && query.aggregateAttribute.type
+			? query.aggregateAttribute.type
+			: '',
 	);
 
 	return (

frontend/src/container/QueryBuilder/filters/GroupByFilter/GroupByFilter.tsx

@@ -75,8 +75,10 @@ export const GroupByFilter = memo(function GroupByFilter({
 										prefix: item.type || '',
 										condition: !item.isColumn,
 									}),
+									!item.isColumn && item.type ? item.type : '',
 								)}
 								dataType={item.dataType || ''}
+								type={item.type || ''}
 							/>
 						),
 						value: `${item.id}`,
@@ -166,6 +168,7 @@ export const GroupByFilter = memo(function GroupByFilter({
 						prefix: item.type || '',
 						condition: !item.isColumn,
 					}),
+					!item.isColumn && item.type ? item.type : '',
 				)}`,
 				value: `${item.id}`,
 			}),

frontend/src/container/QueryBuilder/filters/GroupByFilter/utils.ts

@@ -1,8 +1,9 @@
 import { MetricsType } from 'container/MetricsApplication/constant';
 
-export function removePrefix(str: string): string {
+export function removePrefix(str: string, type: string): string {
 	const tagPrefix = `${MetricsType.Tag}_`;
 	const resourcePrefix = `${MetricsType.Resource}_`;
+	const scopePrefix = `${MetricsType.Scope}_`;
 
 	if (str.startsWith(tagPrefix)) {
 		return str.slice(tagPrefix.length);
@@ -10,5 +11,9 @@ export function removePrefix(str: string): string {
 	if (str.startsWith(resourcePrefix)) {
 		return str.slice(resourcePrefix.length);
 	}
+	if (str.startsWith(scopePrefix) && type === MetricsType.Scope) {
+		return str.slice(scopePrefix.length);
+	}
+
 	return str;
 }

frontend/src/container/QueryBuilder/filters/QueryBuilderSearch/OptionRenderer.tsx

@@ -3,25 +3,23 @@ import './QueryBuilderSearch.styles.scss';
 import { Tooltip } from 'antd';
 
 import { TagContainer, TagLabel, TagValue } from './style';
-import { getOptionType } from './utils';
 
 function OptionRenderer({
 	label,
 	value,
 	dataType,
+	type,
 }: OptionRendererProps): JSX.Element {
-	const optionType = getOptionType(label);
-
 	return (
 		<span className="option">
-			{optionType ? (
+			{type ? (
 				<Tooltip title={`${value}`} placement="topLeft">
 					<div className="selectOptionContainer">
 						<div className="option-value">{value}</div>
 						<div className="option-meta-data-container">
 							<TagContainer>
 								<TagLabel>Type: </TagLabel>
-								<TagValue>{optionType}</TagValue>
+								<TagValue>{type}</TagValue>
 							</TagContainer>
 							<TagContainer>
 								<TagLabel>Data type: </TagLabel>
@@ -43,6 +41,7 @@ interface OptionRendererProps {
 	label: string;
 	value: string;
 	dataType: string;
+	type: string;
 }
 
 export default OptionRenderer;

frontend/src/container/QueryBuilder/filters/QueryBuilderSearch/index.tsx

@@ -410,6 +410,7 @@ function QueryBuilderSearch({
 									label={option.label}
 									value={option.value}
 									dataType={option.dataType || ''}
+									type={option.type || ''}
 								/>
 								{option.selected && <StyledCheckOutlined />}
 							</Select.Option>

frontend/src/container/QueryBuilder/filters/QueryBuilderSearchV2/QueryBuilderSearchV2.styles.scss

@@ -260,6 +260,20 @@
 					background: rgba(189, 153, 121, 0.1);
 				}
 			}
+
+			&.scope {
+				border: 1px solid rgba(113, 144, 249, 0.2);
+
+				.ant-typography {
+					color: var(--bg-robin-400);
+					background: rgba(113, 144, 249, 0.1);
+					font-size: 14px;
+				}
+
+				.ant-tag-close-icon {
+					background: rgba(113, 144, 249, 0.1);
+				}
+			}
 		}
 	}
 }

frontend/src/container/QueryBuilder/filters/QueryBuilderSearchV2/Suggestions.styles.scss

@@ -94,6 +94,25 @@
 						letter-spacing: -0.06px;
 					}
 				}
+
+				&.scope {
+					border-radius: 50px;
+					background: rgba(113, 144, 249, 0.1) !important;
+					color: var(--bg-robin-400) !important;
+
+					.dot {
+						background-color: var(--bg-robin-400);
+					}
+					.text {
+						color: var(--bg-robin-400);
+						font-family: Inter;
+						font-size: 12px;
+						font-style: normal;
+						font-weight: 400;
+						line-height: 18px; /* 150% */
+						letter-spacing: -0.06px;
+					}
+				}
 			}
 		}
 		.option-meta-data-container {