Merge branch 'main' into refactor/update-cloud-integration-version

* fix(alertmanager): remove ambiguous reference to org_id

* fix(alertmanager): remove ambiguous reference to org_id

.github/CODEOWNERS

@@ -47,5 +47,7 @@
 /pkg/telemetrytraces/ @srikanthccv
 
 # AuthN / AuthZ Owners 
-
 /pkg/authz/ @vikrantgupta25 @therealpandey
+
+# Integration tests
+/tests/integration/ @therealpandey

.github/pull_request_template.md

@@ -11,6 +11,20 @@
 
 ---
 
+
+## 📝 Changelog 
+
+> Fill this only if the change affects users, APIs, UI, or documented behavior.
+Mention as N/A for internal refactors or non-user-visible changes.
+
+**Deployment Type:** Cloud / OSS / Enterprise
+
+**Type:** Feature / Bug Fix / Maintenance
+
+**Description:** Short, user-facing summary of the change
+
+---
+
 ## 🏷️ Required: Add Relevant Labels
 
 > ⚠️ **Manually add appropriate labels in the PR sidebar**  

.github/workflows/integrationci.yaml

@@ -45,11 +45,13 @@ jobs:
           - querier
           - ttl
           - preference
+          - logspipelines
         sqlstore-provider:
           - postgres
           - sqlite
         clickhouse-version:
           - 25.5.6
+          - 25.10.1
         schema-migrator-version:
           - v0.129.7
         postgres-version:

Makefile

@@ -210,6 +210,23 @@ py-lint: ## Run lint for integration tests
 	@cd tests/integration && poetry run autoflake .
 	@cd tests/integration && poetry run pylint .
 
+.PHONY: py-test-setup
+py-test-setup: ## Runs integration tests
+	@cd tests/integration && poetry run pytest --basetemp=./tmp/ -vv --reuse --capture=no src/bootstrap/setup.py::test_setup
+
+.PHONY: py-test-teardown
+py-test-teardown: ## Runs integration tests with teardown
+	@cd tests/integration && poetry run pytest --basetemp=./tmp/ -vv --teardown --capture=no  src/bootstrap/setup.py::test_teardown 
+
 .PHONY: py-test
 py-test: ## Runs integration tests
 	@cd tests/integration && poetry run pytest --basetemp=./tmp/ -vv --capture=no src/
+
+.PHONY: py-clean
+py-clean: ## Clear all pycache and pytest cache from tests directory recursively
+	@echo ">> cleaning python cache files from tests directory"
+	@find tests -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true
+	@find tests -type d -name .pytest_cache -exec rm -rf {} + 2>/dev/null || true
+	@find tests -type f -name "*.pyc" -delete 2>/dev/null || true
+	@find tests -type f -name "*.pyo" -delete 2>/dev/null || true
+	@echo ">> python cache cleaned"

cmd/community/server.go

@@ -14,8 +14,13 @@ import (
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/licensing"
 	"github.com/SigNoz/signoz/pkg/licensing/nooplicensing"
+	"github.com/SigNoz/signoz/pkg/modules/dashboard"
+	"github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/modules/role"
+	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/query-service/app"
+	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/signoz"
 	"github.com/SigNoz/signoz/pkg/sqlschema"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
@@ -82,6 +87,9 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 		func(ctx context.Context, sqlstore sqlstore.SQLStore) factory.ProviderFactory[authz.AuthZ, authz.Config] {
 			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx))
 		},
+		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, _ role.Module, queryParser queryparser.QueryParser, _ querier.Querier, _ licensing.Licensing) dashboard.Module {
+			return impldashboard.NewModule(impldashboard.NewStore(store), settings, analytics, orgGetter, queryParser)
+		},
 	)
 	if err != nil {
 		logger.ErrorContext(ctx, "failed to create signoz", "error", err)

cmd/enterprise/server.go

@@ -12,6 +12,7 @@ import (
 	"github.com/SigNoz/signoz/ee/authz/openfgaschema"
 	enterpriselicensing "github.com/SigNoz/signoz/ee/licensing"
 	"github.com/SigNoz/signoz/ee/licensing/httplicensing"
+	"github.com/SigNoz/signoz/ee/modules/dashboard/impldashboard"
 	enterpriseapp "github.com/SigNoz/signoz/ee/query-service/app"
 	"github.com/SigNoz/signoz/ee/sqlschema/postgressqlschema"
 	"github.com/SigNoz/signoz/ee/sqlstore/postgressqlstore"
@@ -22,7 +23,12 @@ import (
 	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/licensing"
+	"github.com/SigNoz/signoz/pkg/modules/dashboard"
+	pkgimpldashboard "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/modules/role"
+	"github.com/SigNoz/signoz/pkg/querier"
+	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/signoz"
 	"github.com/SigNoz/signoz/pkg/sqlschema"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
@@ -111,6 +117,9 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 		func(ctx context.Context, sqlstore sqlstore.SQLStore) factory.ProviderFactory[authz.AuthZ, authz.Config] {
 			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx))
 		},
+		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, role role.Module, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing) dashboard.Module {
+			return impldashboard.NewModule(pkgimpldashboard.NewStore(store), settings, analytics, orgGetter, role, queryParser, querier, licensing)
+		},
 	)
 	if err != nil {
 		logger.ErrorContext(ctx, "failed to create signoz", "error", err)

cmd/zap.go

@@ -1,6 +1,10 @@
 package cmd
 
 import (
+	"context"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
 	"go.uber.org/zap"         //nolint:depguard
 	"go.uber.org/zap/zapcore" //nolint:depguard
 )
@@ -10,6 +14,97 @@ func newZapLogger() *zap.Logger {
 	config := zap.NewProductionConfig()
 	config.EncoderConfig.TimeKey = "timestamp"
 	config.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
+
+	// Extract sampling config before building the logger.
+	// We need to disable sampling in the config and apply it manually later
+	// to ensure correct core ordering. See filteringCore documentation for details.
+	samplerConfig := config.Sampling
+	config.Sampling = nil
+
 	logger, _ := config.Build()
-	return logger
+
+	// Wrap with custom core wrapping to filter certain log entries.
+	// The order of wrapping is important:
+	//   1. First wrap with filteringCore
+	//   2. Then wrap with sampler
+	//
+	// This creates the call chain: sampler -> filteringCore -> ioCore
+	//
+	// During logging:
+	//   - sampler.Check decides whether to sample the log entry
+	//   - If sampled, filteringCore.Check is called
+	//   - filteringCore adds itself to CheckedEntry.cores
+	//   - All cores in CheckedEntry.cores have their Write method called
+	//   - filteringCore.Write can now filter the entry before passing to ioCore
+	//
+	// If we didn't disable the sampler above, filteringCore would have wrapped
+	// sampler. By calling sampler.Check we would have allowed it to call
+	// ioCore.Check that adds itself to CheckedEntry.cores. Then ioCore.Write
+	// would have bypassed our checks, making filtering impossible.
+	return logger.WithOptions(zap.WrapCore(func(core zapcore.Core) zapcore.Core {
+		core = &filteringCore{core}
+		if samplerConfig != nil {
+			core = zapcore.NewSamplerWithOptions(
+				core,
+				time.Second,
+				samplerConfig.Initial,
+				samplerConfig.Thereafter,
+			)
+		}
+		return core
+	}))
+}
+
+// filteringCore wraps a zapcore.Core to filter out log entries based on a
+// custom logic.
+//
+// Note: This core must be positioned before the sampler in the core chain
+// to ensure Write is called. See newZapLogger for ordering details.
+type filteringCore struct {
+	zapcore.Core
+}
+
+// filter determines whether a log entry should be written based on its fields.
+// Returns false if the entry should be suppressed, true otherwise.
+//
+// Current filters:
+//   - context.Canceled: These are expected errors from cancelled operations,
+//     and create noise in logs.
+func (c *filteringCore) filter(fields []zapcore.Field) bool {
+	for _, field := range fields {
+		if field.Type == zapcore.ErrorType {
+			if loggedErr, ok := field.Interface.(error); ok {
+				// Suppress logs containing context.Canceled errors
+				if errors.Is(loggedErr, context.Canceled) {
+					return false
+				}
+			}
+		}
+	}
+	return true
+}
+
+// With implements zapcore.Core.With
+// It returns a new copy with the added context.
+func (c *filteringCore) With(fields []zapcore.Field) zapcore.Core {
+	return &filteringCore{c.Core.With(fields)}
+}
+
+// Check implements zapcore.Core.Check.
+// It adds this core to the CheckedEntry if the log level is enabled,
+// ensuring that Write will be called for this entry.
+func (c *filteringCore) Check(ent zapcore.Entry, ce *zapcore.CheckedEntry) *zapcore.CheckedEntry {
+	if c.Enabled(ent.Level) {
+		return ce.AddCore(ent, c)
+	}
+	return ce
+}
+
+// Write implements zapcore.Core.Write.
+// It filters log entries based on their fields before delegating to the wrapped core.
+func (c *filteringCore) Write(ent zapcore.Entry, fields []zapcore.Field) error {
+	if !c.filter(fields) {
+		return nil
+	}
+	return c.Core.Write(ent, fields)
 }

conf/example.yaml

@@ -278,3 +278,16 @@ tokenizer:
     token:
       # The maximum number of tokens a user can have. This limits the number of concurrent sessions a user can have.
       max_per_user: 5
+
+##################### Flagger #####################
+flagger:
+  # Config are the overrides for the feature flags which come directly from the config file.
+  config:
+    boolean:
+      use_span_metrics: true
+      interpolation_enabled: false
+      kafka_span_eval: false
+    string:
+    float:
+    integer:
+    object:

deploy/docker-swarm/docker-compose.ha.yaml

@@ -176,7 +176,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.105.1
+    image: signoz/signoz:v0.106.0
     command:
       - --config=/root/config/prometheus.yml
     ports:

deploy/docker-swarm/docker-compose.yaml

@@ -117,7 +117,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.105.1
+    image: signoz/signoz:v0.106.0
     command:
       - --config=/root/config/prometheus.yml
     ports:

deploy/docker/docker-compose.ha.yaml

@@ -179,7 +179,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.105.1}
+    image: signoz/signoz:${VERSION:-v0.106.0}
     container_name: signoz
     command:
       - --config=/root/config/prometheus.yml

deploy/docker/docker-compose.yaml

@@ -111,7 +111,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.105.1}
+    image: signoz/signoz:${VERSION:-v0.106.0}
     container_name: signoz
     command:
       - --config=/root/config/prometheus.yml

docs/contributing/go/flagger.md

@@ -0,0 +1,134 @@
+# Flagger
+
+Flagger is SigNoz's feature flagging system built on top of the [OpenFeature](https://openfeature.dev/) standard. It provides a unified interface for evaluating feature flags across the application, allowing features to be enabled, disabled, or configured dynamically without code changes.
+
+> 💡 **Note**: OpenFeature is a CNCF project that provides a vendor-agnostic feature flagging API, making it easy to switch providers without changing application code.
+
+## How does it work?
+
+Flagger consists of three main components:
+
+1. **Registry** (`pkg/flagger/registry.go`) - Contains all available feature flags with their metadata and default values
+2. **Flagger** (`pkg/flagger/flagger.go`) - The consumer-facing interface for evaluating feature flags
+3. **Providers** (`pkg/flagger/<provider>flagger/`) - Implementations that supply feature flag values (e.g., `configflagger` for config-based flags)
+
+The evaluation flow works as follows:
+
+1. The caller requests a feature flag value via the `Flagger` interface
+2. Flagger checks the registry to validate the flag exists and get its default value
+3. Each registered provider is queried for an override value
+4. If a provider returns a value different from the default, that value is returned
+5. Otherwise, the default value from the registry is returned
+
+## How to add a new feature flag?
+
+### 1. Register the flag in the registry
+
+Add your feature flag definition in `pkg/flagger/registry.go`:
+
+```go
+var (
+    // Export the feature name for use in evaluations
+    FeatureMyNewFeature = featuretypes.MustNewName("my_new_feature")
+)
+
+func MustNewRegistry() featuretypes.Registry {
+    registry, err := featuretypes.NewRegistry(
+        // ...existing features...
+        &featuretypes.Feature{
+            Name:           FeatureMyNewFeature,
+            Kind:           featuretypes.KindBoolean, // or KindString, KindFloat, KindInt, KindObject
+            Stage:          featuretypes.StageStable, // or StageAlpha, StageBeta
+            Description:    "Controls whether my new feature is enabled",
+            DefaultVariant: featuretypes.MustNewName("disabled"),
+            Variants:       featuretypes.NewBooleanVariants(),
+        },
+    )
+    // ...
+}
+```
+
+> 💡 **Note**: Feature names must match the regex `^[a-z_]+$` (lowercase letters and underscores only).
+
+### 2. Configure the feature flag value (optional)
+
+To override the default value, add an entry in your configuration file:
+
+```yaml
+flagger:
+  config:
+    boolean:
+      my_new_feature: true
+```
+
+Supported configuration types:
+
+| Type | Config Key | Go Type |
+|------|------------|---------|
+| Boolean | `boolean` | `bool` |
+| String | `string` | `string` |
+| Float | `float` | `float64` |
+| Integer | `integer` | `int64` |
+| Object | `object` | `any` |
+
+## How to evaluate a feature flag?
+
+Use the `Flagger` interface to evaluate feature flags. The interface provides typed methods for each value type:
+
+```go
+import (
+    "github.com/SigNoz/signoz/pkg/flagger"
+    "github.com/SigNoz/signoz/pkg/types/featuretypes"
+)
+
+func DoSomething(ctx context.Context, flagger flagger.Flagger) error {
+    // Create an evaluation context (typically with org ID)
+    evalCtx := featuretypes.NewFlaggerEvaluationContext(orgID)
+    
+    // Evaluate with error handling
+    enabled, err := flagger.Boolean(ctx, flagger.FeatureMyNewFeature, evalCtx)
+    if err != nil {
+        return err
+    }
+    
+    if enabled {
+        // Feature is enabled
+    }
+    
+    return nil
+}
+```
+
+### Empty variants 
+
+For cases where you want to use a default value on error (and log the error), use the `*OrEmpty` methods:
+
+```go
+func DoSomething(ctx context.Context, flagger flagger.Flagger) {
+    evalCtx := featuretypes.NewFlaggerEvaluationContext(orgID)
+    
+    // Returns false on error and logs the error
+    if flagger.BooleanOrEmpty(ctx, flagger.FeatureMyNewFeature, evalCtx) {
+        // Feature is enabled
+    }
+}
+```
+
+### Available evaluation methods
+
+| Method | Return Type | Empty Variant Default |
+|--------|-------------|---------------------|
+| `Boolean()` | `(bool, error)` | `false` |
+| `String()` | `(string, error)` | `""` |
+| `Float()` | `(float64, error)` | `0.0` |
+| `Int()` | `(int64, error)` | `0` |
+| `Object()` | `(any, error)` | `struct{}{}` |
+
+## What should I remember?
+
+- Always define feature flags in the registry (`pkg/flagger/registry.go`) before using them
+- Use descriptive feature names that clearly indicate what the flag controls
+- Prefer `*OrEmpty` methods for non-critical features to avoid error handling overhead
+- Export feature name variables (e.g., `FeatureMyNewFeature`) for type-safe usage across packages
+- Consider the feature's lifecycle stage (`Alpha`, `Beta`, `Stable`) when defining it
+- Providers are evaluated in order; the first non-default value wins

docs/contributing/onboarding.md

@@ -0,0 +1,301 @@
+# Onboarding Configuration Guide
+
+This guide explains how to add new data sources to the SigNoz onboarding flow. The onboarding configuration controls the "New Source" / "Get Started" experience in SigNoz Cloud.
+
+## Configuration File Location
+
+The configuration is located at:
+
+```
+frontend/src/container/OnboardingV2Container/onboarding-configs/onboarding-config-with-links.json
+```
+
+## JSON Structure Overview
+
+The configuration file is a JSON array containing data source objects. Each object represents a selectable option in the onboarding flow.
+
+## Data Source Object Keys
+
+### Required Keys
+
+| Key | Type | Description |
+|-----|------|-------------|
+| `dataSource` | `string` | Unique identifier for the data source (kebab-case, e.g., `"aws-ec2"`) |
+| `label` | `string` | Display name shown to users (e.g., `"AWS EC2"`) |
+| `tags` | `string[]` | Array of category tags for grouping (e.g., `["AWS"]`, `["database"]`) |
+| `module` | `string` | Destination module after onboarding completion |
+| `imgUrl` | `string` | Path to the logo/icon (e.g., `"/Logos/ec2.svg"`) |
+
+### Optional Keys
+
+| Key | Type | Description |
+|-----|------|-------------|
+| `link` | `string` | Docs link to redirect to (e.g., `"/docs/aws-monitoring/ec2/"`) |
+| `relatedSearchKeywords` | `string[]` | Array of keywords for search functionality |
+| `question` | `object` | Nested question object for multi-step flows |
+| `internalRedirect` | `boolean` | When `true`, navigates within the app instead of showing docs |
+
+## Module Values
+
+The `module` key determines where users are redirected after completing onboarding:
+
+| Value | Destination |
+|-------|-------------|
+| `apm` | APM / Traces |
+| `logs` | Logs Explorer |
+| `metrics` | Metrics Explorer |
+| `dashboards` | Dashboards |
+| `infra-monitoring-hosts` | Infrastructure Monitoring - Hosts |
+| `infra-monitoring-k8s` | Infrastructure Monitoring - Kubernetes |
+| `messaging-queues-kafka` | Messaging Queues - Kafka |
+| `messaging-queues-celery` | Messaging Queues - Celery |
+| `integrations` | Integrations page |
+| `home` | Home page |
+| `api-monitoring` | API Monitoring |
+
+## Question Object Structure
+
+The `question` object enables multi-step selection flows:
+
+```json
+{
+  "question": {
+    "desc": "What would you like to monitor?",
+    "type": "select",
+    "helpText": "Choose the telemetry type you want to collect.",
+    "helpLink": "/docs/azure-monitoring/overview/",
+    "helpLinkText": "Read the guide →",
+    "options": [
+        {
+            "key": "logging",
+            "label": "Logs",
+            "imgUrl": "/Logos/azure-vm.svg",
+            "link": "/docs/azure-monitoring/app-service/logging/"
+        },
+        {
+            "key": "metrics",
+            "label": "Metrics",
+            "imgUrl": "/Logos/azure-vm.svg",
+            "link": "/docs/azure-monitoring/app-service/metrics/"
+        },
+        {
+            "key": "tracing",
+            "label": "Traces",
+            "imgUrl": "/Logos/azure-vm.svg",
+            "link": "/docs/azure-monitoring/app-service/tracing/"
+        }
+    ]
+  }
+}
+```
+
+### Question Keys
+
+| Key | Type | Description |
+|-----|------|-------------|
+| `desc` | `string` | Question text displayed to the user |
+| `type` | `string` | Currently only `"select"` is supported |
+| `helpText` | `string` | (Optional) Additional help text below the question |
+| `helpLink` | `string` | (Optional) Docs link for the help section |
+| `helpLinkText` | `string` | (Optional) Text for the help link (default: "Learn more →") |
+| `options` | `array` | Array of option objects |
+
+## Option Object Structure
+
+Options can be simple (direct link) or nested (with another question):
+
+### Simple Option (Direct Link)
+
+```json
+{
+  "key": "aws-ec2-logs",
+  "label": "Logs",
+  "imgUrl": "/Logos/ec2.svg",
+  "link": "/docs/userguide/collect_logs_from_file/"
+}
+```
+
+### Option with Internal Redirect
+
+```json
+{
+  "key": "aws-ec2-metrics-one-click",
+  "label": "One Click AWS",
+  "imgUrl": "/Logos/ec2.svg",
+  "link": "/integrations?integration=aws-integration&service=ec2",
+  "internalRedirect": true
+}
+```
+
+> **Important**: Set `internalRedirect: true` only for internal app routes (like `/integrations?...`). Docs links should NOT have this flag.
+
+### Nested Option (Multi-step Flow)
+
+```json
+{
+  "key": "aws-ec2-metrics",
+  "label": "Metrics",
+  "imgUrl": "/Logos/ec2.svg",
+  "question": {
+    "desc": "How would you like to set up monitoring?",
+    "helpText": "Choose your setup method.",
+    "options": [...]
+  }
+}
+```
+
+## Examples
+
+### Simple Data Source (Direct Link)
+
+```json
+{
+  "dataSource": "aws-elb",
+  "label": "AWS ELB",
+  "tags": ["AWS"],
+  "module": "logs",
+  "relatedSearchKeywords": [
+    "aws",
+    "aws elb",
+    "elb logs",
+    "elastic load balancer"
+  ],
+  "imgUrl": "/Logos/elb.svg",
+  "link": "/docs/aws-monitoring/elb/"
+}
+```
+
+### Data Source with Single Question Level
+
+```json
+{
+  "dataSource": "app-service",
+  "label": "App Service",
+  "imgUrl": "/Logos/azure-vm.svg",
+  "tags": ["Azure"],
+  "module": "apm",
+  "relatedSearchKeywords": ["azure", "app service"],
+  "question": {
+    "desc": "What telemetry data do you want to visualise?",
+    "type": "select",
+    "options": [
+      {
+        "key": "logging",
+        "label": "Logs",
+        "imgUrl": "/Logos/azure-vm.svg",
+        "link": "/docs/azure-monitoring/app-service/logging/"
+      },
+      {
+        "key": "metrics",
+        "label": "Metrics",
+        "imgUrl": "/Logos/azure-vm.svg",
+        "link": "/docs/azure-monitoring/app-service/metrics/"
+      },
+      {
+        "key": "tracing",
+        "label": "Traces",
+        "imgUrl": "/Logos/azure-vm.svg",
+        "link": "/docs/azure-monitoring/app-service/tracing/"
+      }
+    ]
+  }
+}
+```
+
+### Data Source with Nested Questions (2-3 Levels)
+
+```json
+{
+  "dataSource": "aws-ec2",
+  "label": "AWS EC2",
+  "tags": ["AWS"],
+  "module": "logs",
+  "relatedSearchKeywords": ["aws", "aws ec2", "ec2 logs", "ec2 metrics"],
+  "imgUrl": "/Logos/ec2.svg",
+  "question": {
+    "desc": "What would you like to monitor for AWS EC2?",
+    "type": "select",
+    "helpText": "Choose the type of telemetry data you want to collect.",
+    "options": [
+      {
+        "key": "aws-ec2-logs",
+        "label": "Logs",
+        "imgUrl": "/Logos/ec2.svg",
+        "link": "/docs/userguide/collect_logs_from_file/"
+      },
+      {
+        "key": "aws-ec2-metrics",
+        "label": "Metrics",
+        "imgUrl": "/Logos/ec2.svg",
+        "question": {
+          "desc": "How would you like to set up EC2 Metrics monitoring?",
+          "helpText": "One Click uses AWS CloudWatch integration. Manual setup uses OpenTelemetry.",
+          "helpLink": "/docs/aws-monitoring/one-click-vs-manual/",
+          "helpLinkText": "Read the comparison guide →",
+          "options": [
+            {
+              "key": "aws-ec2-metrics-one-click",
+              "label": "One Click AWS",
+              "imgUrl": "/Logos/ec2.svg",
+              "link": "/integrations?integration=aws-integration&service=ec2",
+              "internalRedirect": true
+            },
+            {
+              "key": "aws-ec2-metrics-manual",
+              "label": "Manual Setup",
+              "imgUrl": "/Logos/ec2.svg",
+              "link": "/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/"
+            }
+          ]
+        }
+      }
+    ]
+  }
+}
+```
+
+## Best Practices
+
+### 1. Tags
+
+- Use existing tags when possible: `AWS`, `Azure`, `GCP`, `database`, `logs`, `apm/traces`, `infrastructure monitoring`, `LLM Monitoring`
+- Tags are used for grouping in the sidebar
+- Every data source must have at least one tag
+
+### 2. Search Keywords
+
+- Include variations of the name (e.g., `"aws ec2"`, `"ec2"`, `"ec2 logs"`)
+- Include common misspellings or alternative names
+- Keep keywords lowercase and alphabetically sorted
+
+### 3. Logos
+
+- Place logo files in `public/Logos/`
+- Use SVG format
+- Reference as `"/Logos/your-logo.svg"`
+
+### 4. Links
+
+- Docs links should start with `/docs/` (will be prefixed with DOCS_BASE_URL)
+- Internal app links should start with `/integrations`, `/services`, etc.
+- Only use `internalRedirect: true` for internal app routes
+
+### 5. Keys
+
+- Use kebab-case for `dataSource` and option `key` values
+- Make keys descriptive and unique
+- Follow the pattern: `{service}-{subtype}-{action}` (e.g., `aws-ec2-metrics-one-click`)
+
+## Adding a New Data Source
+
+1. Add your data source object to the JSON array
+2. Ensure the logo exists in `public/Logos/`
+3. Test the flow locally with `yarn dev`
+4. Validation:
+   - Navigate to the [onboarding page](http://localhost:3301/get-started-with-signoz-cloud) on your local machine
+   - Data source appears in the list
+   - Search keywords work correctly
+   - All links redirect to the correct pages
+   - Questions display correct help text and links
+   - Tags are used for grouping in the UI sidebar
+   - Clicking on Configure redirects to the correct page

ee/modules/dashboard/impldashboard/module.go

@@ -0,0 +1,265 @@
+package impldashboard
+
+import (
+	"context"
+	"maps"
+
+	"github.com/SigNoz/signoz/pkg/analytics"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/licensing"
+	"github.com/SigNoz/signoz/pkg/modules/dashboard"
+	pkgimpldashboard "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
+	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/modules/role"
+	"github.com/SigNoz/signoz/pkg/querier"
+	"github.com/SigNoz/signoz/pkg/queryparser"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
+	"github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/roletypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type module struct {
+	pkgDashboardModule dashboard.Module
+	store              dashboardtypes.Store
+	settings           factory.ScopedProviderSettings
+	role               role.Module
+	querier            querier.Querier
+	licensing          licensing.Licensing
+}
+
+func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, role role.Module, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing) dashboard.Module {
+	scopedProviderSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/ee/modules/dashboard/impldashboard")
+	pkgDashboardModule := pkgimpldashboard.NewModule(store, settings, analytics, orgGetter, queryParser)
+
+	return &module{
+		pkgDashboardModule: pkgDashboardModule,
+		store:              store,
+		settings:           scopedProviderSettings,
+		role:               role,
+		querier:            querier,
+		licensing:          licensing,
+	}
+}
+
+func (module *module) CreatePublic(ctx context.Context, orgID valuer.UUID, publicDashboard *dashboardtypes.PublicDashboard) error {
+	_, err := module.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	storablePublicDashboard, err := module.store.GetPublic(ctx, publicDashboard.DashboardID.StringValue())
+	if err != nil && !errors.Ast(err, errors.TypeNotFound) {
+		return err
+	}
+	if storablePublicDashboard != nil {
+		return errors.Newf(errors.TypeAlreadyExists, dashboardtypes.ErrCodePublicDashboardAlreadyExists, "dashboard with id %s is already public", storablePublicDashboard.DashboardID)
+	}
+
+	role, err := module.role.GetOrCreate(ctx, roletypes.NewRole(roletypes.AnonymousUserRoleName, roletypes.AnonymousUserRoleDescription, roletypes.RoleTypeManaged.StringValue(), orgID))
+	if err != nil {
+		return err
+	}
+
+	err = module.role.Assign(ctx, role.ID, orgID, authtypes.MustNewSubject(authtypes.TypeableAnonymous, authtypes.AnonymousUser.StringValue(), orgID, nil))
+	if err != nil {
+		return err
+	}
+
+	additionObject := authtypes.MustNewObject(
+		authtypes.Resource{
+			Name: dashboardtypes.TypeableMetaResourcePublicDashboard.Name(),
+			Type: authtypes.TypeMetaResource,
+		},
+		authtypes.MustNewSelector(authtypes.TypeMetaResource, publicDashboard.ID.String()),
+	)
+
+	err = module.role.PatchObjects(ctx, orgID, role.ID, authtypes.RelationRead, []*authtypes.Object{additionObject}, nil)
+	if err != nil {
+		return err
+	}
+
+	err = module.store.CreatePublic(ctx, dashboardtypes.NewStorablePublicDashboardFromPublicDashboard(publicDashboard))
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (module *module) GetPublic(ctx context.Context, orgID valuer.UUID, dashboardID valuer.UUID) (*dashboardtypes.PublicDashboard, error) {
+	_, err := module.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return nil, errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	storablePublicDashboard, err := module.store.GetPublic(ctx, dashboardID.StringValue())
+	if err != nil {
+		return nil, err
+	}
+
+	return dashboardtypes.NewPublicDashboardFromStorablePublicDashboard(storablePublicDashboard), nil
+}
+
+func (module *module) GetDashboardByPublicID(ctx context.Context, id valuer.UUID) (*dashboardtypes.Dashboard, error) {
+	storableDashboard, err := module.store.GetDashboardByPublicID(ctx, id.StringValue())
+	if err != nil {
+		return nil, err
+	}
+
+	return dashboardtypes.NewDashboardFromStorableDashboard(storableDashboard), nil
+}
+
+func (module *module) GetPublicDashboardSelectorsAndOrg(ctx context.Context, id valuer.UUID, orgs []*types.Organization) ([]authtypes.Selector, valuer.UUID, error) {
+	orgIDs := make([]string, len(orgs))
+	for idx, org := range orgs {
+		orgIDs[idx] = org.ID.StringValue()
+	}
+
+	storableDashboard, err := module.store.GetDashboardByOrgsAndPublicID(ctx, orgIDs, id.StringValue())
+	if err != nil {
+		return nil, valuer.UUID{}, err
+	}
+
+	return []authtypes.Selector{
+		authtypes.MustNewSelector(authtypes.TypeMetaResource, id.StringValue()),
+	}, storableDashboard.OrgID, nil
+}
+
+func (module *module) GetPublicWidgetQueryRange(ctx context.Context, id valuer.UUID, widgetIdx, startTime, endTime uint64) (*querybuildertypesv5.QueryRangeResponse, error) {
+	dashboard, err := module.GetDashboardByPublicID(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+
+	query, err := dashboard.GetWidgetQuery(startTime, endTime, widgetIdx, module.settings.Logger())
+	if err != nil {
+		return nil, err
+	}
+
+	return module.querier.QueryRange(ctx, dashboard.OrgID, query)
+}
+
+func (module *module) UpdatePublic(ctx context.Context, orgID valuer.UUID, publicDashboard *dashboardtypes.PublicDashboard) error {
+	_, err := module.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	return module.store.UpdatePublic(ctx, dashboardtypes.NewStorablePublicDashboardFromPublicDashboard(publicDashboard))
+}
+
+func (module *module) Delete(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
+	dashboard, err := module.Get(ctx, orgID, id)
+	if err != nil {
+		return err
+	}
+
+	if dashboard.Locked {
+		return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "dashboard is locked, please unlock the dashboard to be delete it")
+	}
+
+	err = module.store.RunInTx(ctx, func(ctx context.Context) error {
+		err := module.DeletePublic(ctx, orgID, id)
+		if err != nil && !errors.Ast(err, errors.TypeNotFound) {
+			return err
+		}
+
+		err = module.store.Delete(ctx, orgID, id)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (module *module) DeletePublic(ctx context.Context, orgID valuer.UUID, dashboardID valuer.UUID) error {
+	_, err := module.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	publicDashboard, err := module.GetPublic(ctx, orgID, dashboardID)
+	if err != nil {
+		return err
+	}
+
+	role, err := module.role.GetOrCreate(ctx, roletypes.NewRole(roletypes.AnonymousUserRoleName, roletypes.AnonymousUserRoleDescription, roletypes.RoleTypeManaged.StringValue(), orgID))
+	if err != nil {
+		return err
+	}
+
+	deletionObject := authtypes.MustNewObject(
+		authtypes.Resource{
+			Name: dashboardtypes.TypeableMetaResourcePublicDashboard.Name(),
+			Type: authtypes.TypeMetaResource,
+		},
+		authtypes.MustNewSelector(authtypes.TypeMetaResource, publicDashboard.ID.String()),
+	)
+
+	err = module.role.PatchObjects(ctx, orgID, role.ID, authtypes.RelationRead, nil, []*authtypes.Object{deletionObject})
+	if err != nil {
+		return err
+	}
+
+	err = module.store.DeletePublic(ctx, dashboardID.StringValue())
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (module *module) Collect(ctx context.Context, orgID valuer.UUID) (map[string]any, error) {
+	dashboards, err := module.store.List(ctx, orgID)
+	if err != nil {
+		return nil, err
+	}
+
+	publicDashboards, err := module.store.ListPublic(ctx, orgID)
+	if err != nil {
+		return nil, err
+	}
+
+	stats := make(map[string]any)
+	maps.Copy(stats, dashboardtypes.NewStatsFromStorableDashboards(dashboards))
+	maps.Copy(stats, dashboardtypes.NewStatsFromStorablePublicDashboards(publicDashboards))
+	return stats, nil
+}
+
+func (module *module) Create(ctx context.Context, orgID valuer.UUID, createdBy string, creator valuer.UUID, data dashboardtypes.PostableDashboard) (*dashboardtypes.Dashboard, error) {
+	return module.pkgDashboardModule.Create(ctx, orgID, createdBy, creator, data)
+}
+
+func (module *module) Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.Dashboard, error) {
+	return module.pkgDashboardModule.Get(ctx, orgID, id)
+}
+
+func (module *module) GetByMetricNames(ctx context.Context, orgID valuer.UUID, metricNames []string) (map[string][]map[string]string, error) {
+	return module.pkgDashboardModule.GetByMetricNames(ctx, orgID, metricNames)
+}
+
+func (module *module) MustGetTypeables() []authtypes.Typeable {
+	return module.pkgDashboardModule.MustGetTypeables()
+}
+
+func (module *module) List(ctx context.Context, orgID valuer.UUID) ([]*dashboardtypes.Dashboard, error) {
+	return module.pkgDashboardModule.List(ctx, orgID)
+}
+
+func (module *module) Update(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, data dashboardtypes.UpdatableDashboard, diff int) (*dashboardtypes.Dashboard, error) {
+	return module.pkgDashboardModule.Update(ctx, orgID, id, updatedBy, data, diff)
+}
+
+func (module *module) LockUnlock(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, role types.Role, lock bool) error {
+	return module.pkgDashboardModule.LockUnlock(ctx, orgID, id, updatedBy, role, lock)
+}

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

@@ -21,10 +21,6 @@ import (
 	rules "github.com/SigNoz/signoz/pkg/query-service/rules"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/signoz"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/gorilla/mux"
 )
@@ -101,39 +97,6 @@ func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	router.HandleFunc("/api/v1/billing", am.AdminAccess(ah.getBilling)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/portal", am.AdminAccess(ah.LicensingAPI.Portal)).Methods(http.MethodPost)
 
-	// dashboards
-	router.HandleFunc("/api/v1/dashboards/{id}/public", am.AdminAccess(ah.Signoz.Handlers.Dashboard.CreatePublic)).Methods(http.MethodPost)
-	router.HandleFunc("/api/v1/dashboards/{id}/public", am.AdminAccess(ah.Signoz.Handlers.Dashboard.GetPublic)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/dashboards/{id}/public", am.AdminAccess(ah.Signoz.Handlers.Dashboard.UpdatePublic)).Methods(http.MethodPut)
-	router.HandleFunc("/api/v1/dashboards/{id}/public", am.AdminAccess(ah.Signoz.Handlers.Dashboard.DeletePublic)).Methods(http.MethodDelete)
-
-	// public access for dashboards
-	router.HandleFunc("/api/v1/public/dashboards/{id}", am.CheckWithoutClaims(
-		ah.Signoz.Handlers.Dashboard.GetPublicData,
-		authtypes.RelationRead, authtypes.RelationRead,
-		dashboardtypes.TypeableMetaResourcePublicDashboard,
-		func(req *http.Request, orgs []*types.Organization) ([]authtypes.Selector, valuer.UUID, error) {
-			id, err := valuer.NewUUID(mux.Vars(req)["id"])
-			if err != nil {
-				return nil, valuer.UUID{}, err
-			}
-
-			return ah.Signoz.Modules.Dashboard.GetPublicDashboardOrgAndSelectors(req.Context(), id, orgs)
-		})).Methods(http.MethodGet)
-
-	router.HandleFunc("/api/v1/public/dashboards/{id}/widgets/{index}/query_range", am.CheckWithoutClaims(
-		ah.Signoz.Handlers.Dashboard.GetPublicWidgetQueryRange,
-		authtypes.RelationRead, authtypes.RelationRead,
-		dashboardtypes.TypeableMetaResourcePublicDashboard,
-		func(req *http.Request, orgs []*types.Organization) ([]authtypes.Selector, valuer.UUID, error) {
-			id, err := valuer.NewUUID(mux.Vars(req)["id"])
-			if err != nil {
-				return nil, valuer.UUID{}, err
-			}
-
-			return ah.Signoz.Modules.Dashboard.GetPublicDashboardOrgAndSelectors(req.Context(), id, orgs)
-		})).Methods(http.MethodGet)
-
 	// v3
 	router.HandleFunc("/api/v3/licenses", am.AdminAccess(ah.LicensingAPI.Activate)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v3/licenses", am.AdminAccess(ah.LicensingAPI.Refresh)).Methods(http.MethodPut)

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

@@ -9,9 +9,10 @@ import (
 	"time"
 
 	"github.com/SigNoz/signoz/ee/query-service/constants"
-	pkgError "github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/featuretypes"
 	"github.com/SigNoz/signoz/pkg/types/licensetypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"go.uber.org/zap"
@@ -25,11 +26,7 @@ func (ah *APIHandler) getFeatureFlags(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(w, pkgError.Newf(pkgError.TypeInvalidInput, pkgError.CodeInvalidInput, "orgId is invalid"))
-		return
-	}
+	orgID := valuer.MustNewUUID(claims.OrgID)
 
 	featureSet, err := ah.Signoz.Licensing.GetFeatureFlags(r.Context(), orgID)
 	if err != nil {
@@ -59,13 +56,16 @@ func (ah *APIHandler) getFeatureFlags(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	if constants.IsPreferSpanMetrics {
-		for idx, feature := range featureSet {
-			if feature.Name == licensetypes.UseSpanMetrics {
-				featureSet[idx].Active = true
-			}
-		}
-	}
+	evalCtx := featuretypes.NewFlaggerEvaluationContext(orgID)
+	useSpanMetrics := ah.Signoz.Flagger.BooleanOrEmpty(ctx, flagger.FeatureUseSpanMetrics, evalCtx)
+
+	featureSet = append(featureSet, &licensetypes.Feature{
+		Name:       valuer.NewString(flagger.FeatureUseSpanMetrics.String()),
+		Active:     useSpanMetrics,
+		Usage:      0,
+		UsageLimit: -1,
+		Route:      "",
+	})
 
 	if constants.IsDotMetricsEnabled {
 		for idx, feature := range featureSet {

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

@@ -257,18 +257,20 @@ func (aH *APIHandler) queryRangeV5(rw http.ResponseWriter, req *http.Request) {
 			results = append(results, item)
 		}
 
+		// Build step intervals from the anomaly query
+		stepIntervals := make(map[string]uint64)
+		if anomalyQuery.StepInterval.Duration > 0 {
+			stepIntervals[anomalyQuery.Name] = uint64(anomalyQuery.StepInterval.Duration.Seconds())
+		}
+
 		finalResp := &qbtypes.QueryRangeResponse{
 			Type: queryRangeRequest.RequestType,
-			Data: struct {
-				Results []any `json:"results"`
-			}{
+			Data: qbtypes.QueryData{
 				Results: results,
 			},
-			Meta: struct {
-				RowsScanned  uint64 `json:"rowsScanned"`
-				BytesScanned uint64 `json:"bytesScanned"`
-				DurationMS   uint64 `json:"durationMs"`
-			}{},
+			Meta: qbtypes.ExecStats{
+				StepIntervals: stepIntervals,
+			},
 		}
 
 		render.Success(rw, http.StatusOK, finalResp)

ee/query-service/constants/constants.go

@@ -23,14 +23,9 @@ func GetOrDefaultEnv(key string, fallback string) string {
 const DotMetricsEnabled = "DOT_METRICS_ENABLED"
 
 var IsDotMetricsEnabled = false
-var IsPreferSpanMetrics = false
 
 func init() {
 	if GetOrDefaultEnv(DotMetricsEnabled, "true") == "true" {
 		IsDotMetricsEnabled = true
 	}
-
-	if GetOrDefaultEnv("USE_SPAN_METRICS", "false") == "true" {
-		IsPreferSpanMetrics = true
-	}
 }

frontend/.eslintrc.js

@@ -120,5 +120,6 @@ module.exports = {
 				usePrettierrc: true,
 			},
 		],
+		'react/jsx-props-no-spreading': 'off',
 	},
 };

frontend/public/Logos/agno.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <image width="100" height="100" href="data:image/webp;base64,UklGRqQEAABXRUJQVlA4IJgEAACQJQCdASrhAOEAPm02mUikIyKhJVZ4CIANiWVu4XPw+dx/zz8Y9kq6J+Kv5T8nN4H6MM2Hod6xffvuy+jnoX8wD9Zekj5gP2S/YDsAegB+ovWUeg9/GfPP/cn4dP2/9JnVbPMU2BWP/6ShYsB/INjyXNw88GLWEjqTk7r3B1Jyd0Q60mjXFTuiHUwvdoU9QiTOwXp8O6KdYSPcXtgV/YIjrUu+9aTZYQwhSBOiHuLpesMKhiEeAz91s6AFmAINNYJeBpyuf9KScX17NiZWEjlmJ+PsBWx4Be/O9Vng220j2g97IwDP4CHt7ScFK+ikuWNp4z1G60XIv5OXis+Sp/e/QkOjbE0qKut3VrL3hQfSVuuLp2XQBvxPw8eyiMbE05kQ6k5O6Ml23DSy92Ix+s9tw0svcgAA/Jba8JQ+0uNQuBewKWqirnyDRkjzUXXOeoNxj0dA3QpklBe8QAAMu8geavhwzfTJ2OUqOrwpg8PXz6sktEQLDnTlNclju/V9f4Ny3CgDYwBvljjNaFA8PR18BGAyzmVuHsa0hgskCkgbT6nZi/Vr9AXTc/UZtUS8Z3pKg4hMjWCXdMx0JCsu6v+8ghZmHf/y0VcGbDiugOy3WH36R3zSOIJh1NjhcNYlKfWilZD5ohEfCaTn/D4u3kgC/kLeLF06X5oe/zKySrWWEPQe965rTf4pcEGBZQGkauwtkLPJWVcHoNzJshb6gdVqs0hye7fI5nFTsbJaZmqz8kXeMSEV4zhApVaDyl3Q2P/ATfChzCP87kOBxeVrhSkNkMWS/e1j58dVzpyTubHOt04Z2NKpTlEjBganrkKIYvtuYWGoJWEmtMVtM9TuzNWa3jKX3kWc9zWmQHHawveaHnJn4HJXQwbTC4ZIlxa5el1b8GgqUXzOeF9LIWA3eb7i34/Q3GXZcbs5DLsukl03KclLo5hW5uf04JjGQR5NXHd8as68c3K9Kze3147QuIn1ytP7uE9us639xDuAiHDPr9JiVn62mv80Q2ErNLD+d6VYdhm6J2PCLY5/9mHTExTnIBzRtNoErP6qmMiCXmSM4sX7s14u3yhaE+dVjX1xtxUWtFjH0GWCN/1JNmjtElHq+FjqPWse7tIMvkKm7xFBgoM8yUJGxY+HviWNkOHipLPh7RJ3KehnEZTPIhR5GHlhlATLx+QUQ61+WwhffiT45KPRiK9v8Cd+1YShd6ZGqFSqsxt4FuMSvpMUB+Rd51pUUPuwXHzpXcyz6BXkWw0Mi3jbfH3kxet2Bsqzu0XWmJ2Oj097qP4ayirQzJewKHo8LS0cFG73Lvox2tmD7ZhuRRVmGjyz62sUMVDSzIUN2BHghed2IdUHVnAkof5DrdZIx+umeHp2XSityHdbTywo7r1+ve5+vPk8hhxhISBjbK+qikfPVnhJ8R/L7KUUqchh3AGKVmRGVgXh09MDaEiW/qqPYzP+MBiKfM5eTcHuGLymyFvT2em/o58zIcp7nKtDr90BsurnuOA0XaH3ZPDpSFAUN3HL9Zj7mpQtcFMfpCaC1VMv0l2UvY8xo/6qYAG6UEbsogAAAAA=" />
+</svg>

frontend/public/Logos/inkeep.svg

@@ -0,0 +1,4 @@
+<svg width="361" height="224" viewBox="0 0 361 224" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M67.3465 4.3208C62.5234 4.3208 58.0667 6.89389 55.6552 11.0708L1.80865 104.336C-0.602889 108.513 -0.602883 113.659 1.80866 117.836L55.6552 211.101C58.0667 215.277 62.5234 217.851 67.3465 217.851H175.039C179.863 217.851 184.319 215.277 186.731 211.101L240.577 117.836C242.989 113.659 242.989 108.513 240.577 104.336L186.731 11.0708C184.319 6.89388 179.863 4.3208 175.039 4.3208L67.3465 4.3208Z" fill="#D5E5FF"/>
+<path d="M287.008 2.29488C319.287 10.6012 315.609 28.9193 328.995 66.1793C337.583 90.084 379.104 119.725 341.16 177.344C329.837 194.54 293.425 214.941 267.079 220.6C209.035 232.875 174.834 205.018 144.494 159.09C121.73 124.349 129.773 74.335 164.299 49.7761C197.018 26.5653 244.576 -9.45146 287.008 2.29488Z" fill="#69A3FF"/>
+</svg>

frontend/public/Logos/livekit.svg

@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>LiveKit</title><path d="M14 10h-4v4h4v-4zM18 6h-4v4.001h4v-4zM18 14h-4v4h4v-4zM22 2h-4v4h4V2zM22 18h-4v4h4v-4z" fill="#1FD5F9"></path><path d="M6 18V2H2v20h12v-4H6z" fill="#fff"></path></svg>

frontend/public/Logos/pipecat.svg

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" width="280" height="280">
+<path d="M0 0 C92.4 0 184.8 0 280 0 C280 92.4 280 184.8 280 280 C187.6 280 95.2 280 0 280 C0 187.6 0 95.2 0 0 Z " fill="#FEFEFE" transform="translate(0,0)"/>
+<path d="M0 0 C4.32048747 1.62223107 6.55486576 4.28030505 9.52734375 7.72265625 C10.09864014 8.36162842 10.66993652 9.00060059 11.25854492 9.65893555 C12.88271439 11.48112369 14.48833898 13.3180548 16.08984375 15.16015625 C16.78851563 15.9490625 17.4871875 16.73796875 18.20703125 17.55078125 C18.76648438 18.185 19.3259375 18.81921875 19.90234375 19.47265625 C20.40076782 20.02429947 20.89919189 20.57594269 21.41271973 21.14430237 C23.08984375 23.16015625 23.08984375 23.16015625 24.49304199 25.45811462 C27.47252811 29.81453108 29.71272364 31.88015293 34.97558594 32.95022583 C39.9205962 33.32069047 44.85650654 33.17298906 49.80859375 33.0390625 C51.63558812 33.02225785 53.46262328 33.00945545 55.28967285 33.00047302 C60.07802047 32.96625339 64.86387621 32.87797816 69.65124512 32.77813721 C74.54449761 32.68575224 79.43815637 32.64489784 84.33203125 32.59960938 C93.91905835 32.50334235 103.50424315 32.34991947 113.08984375 32.16015625 C113.38173584 31.5460791 113.67362793 30.93200195 113.97436523 30.29931641 C115.36028726 27.64152503 117.11916807 25.73686678 119.15234375 23.53515625 C119.95414063 22.65988281 120.7559375 21.78460938 121.58203125 20.8828125 C122.82339844 19.53509766 122.82339844 19.53509766 124.08984375 18.16015625 C125.6549797 16.43337512 127.21756353 14.70427667 128.77734375 12.97265625 C129.51984375 12.15539062 130.26234375 11.338125 131.02734375 10.49609375 C132.86324628 8.41679505 134.56732791 6.27970771 136.27734375 4.09765625 C138.30731891 1.73122112 139.11199786 1.15156588 142.15234375 -0.02734375 C146.07530165 0.22305782 147.37097322 1.35790253 150.08984375 4.16015625 C150.69111633 7.33660889 150.69111633 7.33660889 150.6574707 11.13183594 C150.6585659 12.17146736 150.6585659 12.17146736 150.65968323 13.23210144 C150.65620792 15.51621591 150.61735535 17.79827448 150.578125 20.08203125 C150.56879653 21.66814052 150.56168057 23.25426423 150.5566864 24.84039307 C150.53761889 29.00990759 150.48852138 33.17854766 150.4331665 37.34771729 C150.381968 41.60408702 150.35917115 45.86059842 150.33398438 50.1171875 C150.28040107 58.46528927 150.19246835 66.81251315 150.08984375 75.16015625 C158.00984375 75.16015625 165.92984375 75.16015625 174.08984375 75.16015625 C174.08984375 80.11015625 174.08984375 85.06015625 174.08984375 90.16015625 C161.54984375 90.16015625 149.00984375 90.16015625 136.08984375 90.16015625 C135.75984375 70.03015625 135.42984375 49.90015625 135.08984375 29.16015625 C126.87476058 37.9752561 126.87476058 37.9752561 119.08984375 47.16015625 C115.79274781 48.80870422 112.12209411 48.32562514 108.49682617 48.3371582 C107.60723709 48.3437294 106.71764801 48.3503006 105.80110168 48.35707092 C102.84917116 48.37682562 99.89729154 48.38847111 96.9453125 48.3984375 C95.43493125 48.40455079 95.43493125 48.40455079 93.89403725 48.41078758 C88.56502105 48.4316572 83.23603067 48.44595528 77.90698242 48.45532227 C72.39874211 48.46639094 66.89090531 48.50079372 61.38280773 48.54049397 C57.15089662 48.56662113 52.91908223 48.57501062 48.68709755 48.57860374 C46.6565001 48.58347949 44.62590725 48.59512145 42.59538841 48.61364174 C39.75361399 48.63795098 36.91289116 48.63708321 34.07104492 48.63012695 C33.23189545 48.64293701 32.39274597 48.65574707 31.52816772 48.66894531 C27.52364757 48.63320802 25.5843855 48.48069887 22.14155579 46.24919128 C20.24828704 44.32148181 18.40141019 42.40710858 16.65234375 40.34765625 C16.11738281 39.72246094 15.58242187 39.09726563 15.03125 38.453125 C14.39058594 37.69644531 13.74992187 36.93976563 13.08984375 36.16015625 C11.10984375 33.85015625 9.12984375 31.54015625 7.08984375 29.16015625 C6.75984375 49.29015625 6.42984375 69.42015625 6.08984375 90.16015625 C-6.45015625 90.16015625 -18.99015625 90.16015625 -31.91015625 90.16015625 C-31.91015625 85.21015625 -31.91015625 80.26015625 -31.91015625 75.16015625 C-23.99015625 75.16015625 -16.07015625 75.16015625 -7.91015625 75.16015625 C-7.93634033 73.03030273 -7.96252441 70.90044922 -7.98950195 68.70605469 C-8.07234699 61.66938098 -8.1275781 54.63268573 -8.16921711 47.59565353 C-8.19531224 43.32896888 -8.23070773 39.06278382 -8.28735352 34.79638672 C-8.34167786 30.67907045 -8.37157742 26.5622347 -8.38454247 22.44458771 C-8.39378174 20.87364384 -8.41182439 19.30272631 -8.43880653 17.731987 C-8.47510571 15.53135855 -8.48010172 13.33271556 -8.4777832 11.13183594 C-8.48888626 9.87941101 -8.49998932 8.62698608 -8.51142883 7.33660889 C-7.91015625 4.16015625 -7.91015625 4.16015625 -5.55656433 1.73443604 C-2.91015625 0.16015625 -2.91015625 0.16015625 0 0 Z " fill="#000000" transform="translate(68.91015625,79.83984375)"/>
+<path d="M0 0 C12.54 0 25.08 0 38 0 C38 4.95 38 9.9 38 15 C25.46 15 12.92 15 0 15 C0 10.05 0 5.1 0 0 Z " fill="#000000" transform="translate(205,185)"/>
+<path d="M0 0 C12.54 0 25.08 0 38 0 C38 4.95 38 9.9 38 15 C25.46 15 12.92 15 0 15 C0 10.05 0 5.1 0 0 Z " fill="#000000" transform="translate(37,185)"/>
+<path d="M0 0 C3.5386994 1.65139305 4.81070153 2.71605229 7 6 C7.34061873 9.0169088 7.57212107 11.09407815 7 14 C4.05423033 17.64345196 1.88105815 19.79099354 -2.8125 20.3125 C-6.7307645 19.92835642 -8.21293267 18.70743683 -11 16 C-12.74330022 12.51339956 -12.5706106 8.80407065 -12 5 C-8.64770496 0.02234979 -5.86333845 -0.83761978 0 0 Z " fill="#050505" transform="translate(109,150)"/>
+<path d="M0 0 C3.09459236 2.57882697 4.55423234 4.12558351 5.4765625 8.00390625 C5.75079474 11.80707441 5.1142302 13.83730851 2.9375 16.9375 C-0.57823396 19.40599406 -2.71383323 20 -7 20 C-10.57387602 18.41161066 -11.81089572 17.28365642 -14 14 C-14.67226891 7.05322129 -14.67226891 7.05322129 -12.125 3.0625 C-8.53966618 -0.41738282 -4.85970455 -0.95707375 0 0 Z " fill="#040404" transform="translate(178,150)"/>
+</svg>

frontend/src/api/globalConfig/getGlobalConfig.ts

@@ -0,0 +1,25 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import {
+	GlobalConfigData,
+	GlobalConfigDataProps,
+} from 'types/api/globalConfig/types';
+
+const getGlobalConfig = async (): Promise<
+	SuccessResponseV2<GlobalConfigData>
+> => {
+	try {
+		const response = await axios.get<GlobalConfigDataProps>(`/global/config`);
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default getGlobalConfig;

frontend/src/api/metricsExplorer/v2/getMetricMetadata.ts

@@ -0,0 +1,29 @@
+import { ApiV2Instance as axios } from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorResponseV2, ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { MetricMetadataResponse } from 'types/api/metricsExplorer/v2/getMetricMetadata';
+
+export const getMetricMetadata = async (
+	metricName: string,
+	signal?: AbortSignal,
+	headers?: Record<string, string>,
+): Promise<SuccessResponseV2<MetricMetadataResponse> | ErrorResponseV2> => {
+	try {
+		const encodedMetricName = encodeURIComponent(metricName);
+		const response = await axios.get(
+			`/metrics/metadata?metricName=${encodedMetricName}`,
+			{
+				signal,
+				headers,
+			},
+		);
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};

frontend/src/components/ExplorerCard/test/ExplorerCard.test.tsx

@@ -59,7 +59,7 @@ jest.mock('providers/preferences/sync/usePreferenceSync', () => ({
 		preferences: {
 			columns: [],
 			formatting: {
-				maxLines: 2,
+				maxLines: 1,
 				format: 'table',
 				fontSize: 'small',
 				version: 1,

frontend/src/components/InputWithLabel/InputWithLabel.styles.scss

@@ -50,6 +50,13 @@
 			color: var(--bg-vanilla-400) !important;
 			font-size: 12px !important;
 		}
+		&[type='number']::-webkit-inner-spin-button,
+		&[type='number']::-webkit-outer-spin-button {
+			-webkit-appearance: none;
+			-moz-appearance: none;
+			appearance: none;
+			margin: 0;
+		}
 	}
 
 	.close-btn {

frontend/src/components/Logs/ListLogView/index.tsx

@@ -14,7 +14,7 @@ import { useIsDarkMode } from 'hooks/useDarkMode';
 // utils
 import { FlatLogData } from 'lib/logs/flatLogData';
 import { useTimezone } from 'providers/Timezone';
-import { useCallback, useMemo, useState } from 'react';
+import { memo, useCallback, useMemo } from 'react';
 // interfaces
 import { IField } from 'types/api/logs/fields';
 import { ILog } from 'types/api/logs/log';
@@ -121,10 +121,11 @@ function ListLogView({
 }: ListLogViewProps): JSX.Element {
 	const flattenLogData = useMemo(() => FlatLogData(logData), [logData]);
 
-	const [hasActionButtons, setHasActionButtons] = useState<boolean>(false);
 	const { isHighlighted, isLogsExplorerPage, onLogCopy } = useCopyLogLink(
 		logData.id,
 	);
+	const isReadOnlyLog = !isLogsExplorerPage;
+
 	const {
 		activeLog: activeContextLog,
 		onAddToQuery: handleAddToQuery,
@@ -180,14 +181,6 @@ function ListLogView({
 
 	const logType = getLogIndicatorType(logData);
 
-	const handleMouseEnter = (): void => {
-		setHasActionButtons(true);
-	};
-
-	const handleMouseLeave = (): void => {
-		setHasActionButtons(false);
-	};
-
 	return (
 		<>
 			<Container
@@ -198,8 +191,6 @@ function ListLogView({
 				}
 				$isDarkMode={isDarkMode}
 				$logType={logType}
-				onMouseEnter={handleMouseEnter}
-				onMouseLeave={handleMouseLeave}
 				onClick={handleDetailedView}
 				fontSize={fontSize}
 			>
@@ -251,7 +242,7 @@ function ListLogView({
 					</div>
 				</div>
 
-				{hasActionButtons && isLogsExplorerPage && (
+				{!isReadOnlyLog && (
 					<LogLinesActionButtons
 						handleShowContext={handleShowContext}
 						onLogCopy={onLogCopy}
@@ -279,4 +270,4 @@ LogGeneralField.defaultProps = {
 	linesPerRow: 1,
 };
 
-export default ListLogView;
+export default memo(ListLogView);

frontend/src/components/Logs/ListLogView/styles.ts

@@ -30,6 +30,11 @@ export const Container = styled(Card)<{
 			? `margin-bottom:0.3rem;`
 			: ``}
 	cursor: pointer;
+
+	&:not(:hover) .log-line-action-buttons {
+		display: none;
+	}
+
 	.ant-card-body {
 		padding: 0.3rem 0.6rem;
 

frontend/src/components/Logs/LogLinesActionButtons/LogLinesActionButtons.tsx

@@ -3,14 +3,15 @@ import './LogLinesActionButtons.styles.scss';
 import { LinkOutlined } from '@ant-design/icons';
 import { Button, Tooltip } from 'antd';
 import { TextSelect } from 'lucide-react';
-import { MouseEventHandler } from 'react';
+import { memo, MouseEventHandler } from 'react';
 
 export interface LogLinesActionButtonsProps {
 	handleShowContext: MouseEventHandler<HTMLElement>;
 	onLogCopy: MouseEventHandler<HTMLElement>;
 	customClassName?: string;
 }
-export default function LogLinesActionButtons({
+
+function LogLinesActionButtons({
 	handleShowContext,
 	onLogCopy,
 	customClassName = '',
@@ -40,3 +41,5 @@ export default function LogLinesActionButtons({
 LogLinesActionButtons.defaultProps = {
 	customClassName: '',
 };
+
+export default memo(LogLinesActionButtons);

frontend/src/components/Logs/RawLogView/index.tsx

@@ -4,7 +4,6 @@ import LogDetail from 'components/LogDetail';
 import { VIEW_TYPES, VIEWS } from 'components/LogDetail/constants';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
 import { getSanitizedLogBody } from 'container/LogDetailedView/utils';
-import LogsExplorerContext from 'container/LogsExplorerContext';
 import { useActiveLog } from 'hooks/logs/useActiveLog';
 import { useCopyLogLink } from 'hooks/logs/useCopyLogLink';
 // hooks
@@ -14,6 +13,7 @@ import { isEmpty, isNumber, isUndefined } from 'lodash-es';
 import { useTimezone } from 'providers/Timezone';
 import {
 	KeyboardEvent,
+	memo,
 	MouseEvent,
 	MouseEventHandler,
 	useCallback,
@@ -47,10 +47,6 @@ function RawLogView({
 	} = useCopyLogLink(data.id);
 	const flattenLogData = useMemo(() => FlatLogData(data), [data]);
 
-	const {
-		activeLog: activeContextLog,
-		onClearActiveLog: handleClearActiveContextLog,
-	} = useActiveLog();
 	const {
 		activeLog,
 		onSetActiveLog,
@@ -59,7 +55,6 @@ function RawLogView({
 		onGroupByAttribute,
 	} = useActiveLog();
 
-	const [hasActionButtons, setHasActionButtons] = useState<boolean>(false);
 	const [selectedTab, setSelectedTab] = useState<VIEWS | undefined>();
 
 	const isDarkMode = useIsDarkMode();
@@ -132,7 +127,7 @@ function RawLogView({
 
 	const handleClickExpand = useCallback(
 		(event: MouseEvent) => {
-			if (activeContextLog || isReadOnly) return;
+			if (isReadOnly) return;
 
 			// Use custom click handler if provided, otherwise use default behavior
 			if (onLogClick) {
@@ -142,7 +137,7 @@ function RawLogView({
 				setSelectedTab(VIEW_TYPES.OVERVIEW);
 			}
 		},
-		[activeContextLog, isReadOnly, data, onSetActiveLog, onLogClick],
+		[isReadOnly, data, onSetActiveLog, onLogClick],
 	);
 
 	const handleCloseLogDetail: DrawerProps['onClose'] = useCallback(
@@ -158,18 +153,6 @@ function RawLogView({
 		[onClearActiveLog],
 	);
 
-	const handleMouseEnter = useCallback(() => {
-		if (isReadOnlyLog) return;
-
-		setHasActionButtons(true);
-	}, [isReadOnlyLog]);
-
-	const handleMouseLeave = useCallback(() => {
-		if (isReadOnlyLog) return;
-
-		setHasActionButtons(false);
-	}, [isReadOnlyLog]);
-
 	const handleShowContext: MouseEventHandler<HTMLElement> = useCallback(
 		(event) => {
 			event.preventDefault();
@@ -196,13 +179,9 @@ function RawLogView({
 			$isDarkMode={isDarkMode}
 			$isReadOnly={isReadOnly}
 			$isHightlightedLog={isUrlHighlighted}
-			$isActiveLog={
-				activeLog?.id === data.id || activeContextLog?.id === data.id || isActiveLog
-			}
+			$isActiveLog={activeLog?.id === data.id || isActiveLog}
 			$isCustomHighlighted={isHighlighted}
 			$logType={logType}
-			onMouseEnter={handleMouseEnter}
-			onMouseLeave={handleMouseLeave}
 			fontSize={fontSize}
 		>
 			<LogStateIndicator
@@ -231,19 +210,13 @@ function RawLogView({
 				dangerouslySetInnerHTML={html}
 			/>
 
-			{hasActionButtons && (
+			{!isReadOnlyLog && (
 				<LogLinesActionButtons
 					handleShowContext={handleShowContext}
 					onLogCopy={onLogCopy}
 				/>
 			)}
 
-			{activeContextLog && (
-				<LogsExplorerContext
-					log={activeContextLog}
-					onClose={handleClearActiveContextLog}
-				/>
-			)}
 			{selectedTab && (
 				<LogDetail
 					selectedTab={selectedTab}
@@ -265,4 +238,4 @@ RawLogView.defaultProps = {
 	isHighlighted: false,
 };
 
-export default RawLogView;
+export default memo(RawLogView);

frontend/src/components/Logs/RawLogView/styles.ts

@@ -30,6 +30,10 @@ export const RawLogViewContainer = styled(Row)<{
 
 	transition: background-color 0.2s ease-in;
 
+	&:not(:hover) .log-line-action-buttons {
+		display: none;
+	}
+
 	.log-state-indicator {
 		margin: 4px 0;
 

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

@@ -10,7 +10,7 @@ jest.mock('providers/preferences/sync/usePreferenceSync', () => ({
 		preferences: {
 			columns: [],
 			formatting: {
-				maxLines: 2,
+				maxLines: 1,
 				format: 'table',
 				fontSize: 'small',
 				version: 1,
@@ -51,7 +51,7 @@ describe('LogsFormatOptionsMenu (unit)', () => {
 				selectedOptionFormat="table"
 				config={{
 					format: { value: 'table', onChange: formatOnChange },
-					maxLines: { value: 2, onChange: maxLinesOnChange },
+					maxLines: { value: 1, onChange: maxLinesOnChange },
 					fontSize: { value: FontSize.SMALL, onChange: fontSizeOnChange },
 					addColumn: {
 						isFetching: false,

frontend/src/components/QueryBuilderV2/QueryBuilderV2.styles.scss

@@ -560,6 +560,10 @@
 					border: 1px solid var(--bg-vanilla-300) !important;
 					background: var(--bg-vanilla-100) !important;
 					box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, 0.1) !important;
+
+					.ant-select-selection-item {
+						color: var(--text-ink-400);
+					}
 				}
 			}
 		}
@@ -569,6 +573,10 @@
 				border: 1px solid var(--bg-vanilla-300) !important;
 				background: var(--bg-vanilla-100) !important;
 				box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, 0.1) !important;
+
+				.ant-select-selection-item {
+					color: var(--text-ink-400);
+				}
 			}
 
 			.ant-select-arrow {

frontend/src/components/QueryBuilderV2/QueryV2/MerticsAggregateSection/MetricsAggregateSection.styles.scss

@@ -169,6 +169,10 @@
 					.ant-select-selector {
 						border: 1px solid var(--bg-vanilla-300) !important;
 						background: var(--bg-vanilla-100) !important;
+
+						.ant-select-selection-item {
+							color: var(--text-ink-400);
+						}
 					}
 				}
 			}

frontend/src/components/QueryBuilderV2/QueryV2/QueryAddOns/QueryAddOns.tsx

@@ -32,6 +32,7 @@ const ADD_ONS_KEYS = {
 	ORDER_BY: 'order_by',
 	LIMIT: 'limit',
 	LEGEND_FORMAT: 'legend_format',
+	REDUCE_TO: 'reduce_to',
 };
 
 const ADD_ONS_KEYS_TO_QUERY_PATH = {
@@ -40,13 +41,14 @@ const ADD_ONS_KEYS_TO_QUERY_PATH = {
 	[ADD_ONS_KEYS.ORDER_BY]: 'orderBy',
 	[ADD_ONS_KEYS.LIMIT]: 'limit',
 	[ADD_ONS_KEYS.LEGEND_FORMAT]: 'legend',
+	[ADD_ONS_KEYS.REDUCE_TO]: 'reduceTo',
 };
 
 const ADD_ONS = [
 	{
 		icon: <BarChart2 size={14} />,
 		label: 'Group By',
-		key: 'group_by',
+		key: ADD_ONS_KEYS.GROUP_BY,
 		description:
 			'Break down data by attributes like service name, endpoint, status code, or region. Essential for spotting patterns and comparing performance across different segments.',
 		docLink: 'https://signoz.io/docs/userguide/query-builder-v5/#grouping',
@@ -54,7 +56,7 @@ const ADD_ONS = [
 	{
 		icon: <ScrollText size={14} />,
 		label: 'Having',
-		key: 'having',
+		key: ADD_ONS_KEYS.HAVING,
 		description:
 			'Filter grouped results based on aggregate conditions. Show only groups meeting specific criteria, like error rates > 5% or p99 latency > 500',
 		docLink:
@@ -63,7 +65,7 @@ const ADD_ONS = [
 	{
 		icon: <ScrollText size={14} />,
 		label: 'Order By',
-		key: 'order_by',
+		key: ADD_ONS_KEYS.ORDER_BY,
 		description:
 			'Sort results to surface what matters most. Quickly identify slowest operations, most frequent errors, or highest resource consumers.',
 		docLink:
@@ -72,7 +74,7 @@ const ADD_ONS = [
 	{
 		icon: <ScrollText size={14} />,
 		label: 'Limit',
-		key: 'limit',
+		key: ADD_ONS_KEYS.LIMIT,
 		description:
 			'Show only the top/bottom N results. Perfect for focusing on outliers, reducing noise, and improving dashboard performance.',
 		docLink:
@@ -81,7 +83,7 @@ const ADD_ONS = [
 	{
 		icon: <ScrollText size={14} />,
 		label: 'Legend format',
-		key: 'legend_format',
+		key: ADD_ONS_KEYS.LEGEND_FORMAT,
 		description:
 			'Customize series labels using variables like {{service.name}}-{{endpoint}}. Makes charts readable at a glance during incident investigation.',
 		docLink:
@@ -92,7 +94,7 @@ const ADD_ONS = [
 const REDUCE_TO = {
 	icon: <ScrollText size={14} />,
 	label: 'Reduce to',
-	key: 'reduce_to',
+	key: ADD_ONS_KEYS.REDUCE_TO,
 	description:
 		'Apply mathematical operations like sum, average, min, max, or percentiles to reduce multiple time series into a single value.',
 	docLink:
@@ -218,10 +220,9 @@ function QueryAddOns({
 		);
 
 		const availableAddOnKeys = new Set(filteredAddOns.map((addOn) => addOn.key));
-
 		// Filter and set selected views: add-ons that are both active and available
 		setSelectedViews(
-			ADD_ONS.filter(
+			filteredAddOns.filter(
 				(addOn) =>
 					activeAddOnKeys.has(addOn.key) && availableAddOnKeys.has(addOn.key),
 			),
@@ -375,6 +376,7 @@ function QueryAddOns({
 						<div className="add-on-content" data-testid="limit-content">
 							<InputWithLabel
 								label="Limit"
+								type="number"
 								onChange={handleChangeLimit}
 								initialValue={query?.limit ?? undefined}
 								placeholder="Enter limit"

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

@@ -0,0 +1,118 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable react/display-name */
+import '@testing-library/jest-dom';
+
+import { jest } from '@jest/globals';
+import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
+import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
+import { render, screen } from 'tests/test-utils';
+import { Having, IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+import { UseQueryOperations } from 'types/common/operations.types';
+import { DataSource, QueryBuilderContextType } from 'types/common/queryBuilder';
+
+import { QueryV2 } from '../QueryV2';
+
+// Local mocks for domain-specific heavy child components
+jest.mock(
+	'../QueryAggregation/QueryAggregation',
+	() =>
+		function () {
+			return <div>QueryAggregation</div>;
+		},
+);
+jest.mock(
+	'../MerticsAggregateSection/MetricsAggregateSection',
+	() =>
+		function () {
+			return <div>MetricsAggregateSection</div>;
+		},
+);
+// Mock hooks
+jest.mock('hooks/queryBuilder/useQueryBuilder');
+jest.mock('hooks/queryBuilder/useQueryBuilderOperations');
+
+const mockedUseQueryBuilder = jest.mocked(useQueryBuilder);
+const mockedUseQueryOperations = jest.mocked(
+	useQueryOperations,
+) as jest.MockedFunction<UseQueryOperations>;
+
+describe('QueryV2 - base render', () => {
+	beforeEach(() => {
+		const mockCloneQuery = jest.fn() as jest.MockedFunction<
+			(type: string, q: IBuilderQuery) => void
+		>;
+
+		mockedUseQueryBuilder.mockReturnValue(({
+			// Only fields used by QueryV2
+			cloneQuery: mockCloneQuery,
+			panelType: null,
+		} as unknown) as QueryBuilderContextType);
+
+		mockedUseQueryOperations.mockReturnValue({
+			isTracePanelType: false,
+			isMetricsDataSource: false,
+			operators: [],
+			spaceAggregationOptions: [],
+			listOfAdditionalFilters: [],
+			handleChangeOperator: jest.fn(),
+			handleSpaceAggregationChange: jest.fn(),
+			handleChangeAggregatorAttribute: jest.fn(),
+			handleChangeDataSource: jest.fn(),
+			handleDeleteQuery: jest.fn(),
+			handleChangeQueryData: (jest.fn() as unknown) as ReturnType<UseQueryOperations>['handleChangeQueryData'],
+			handleChangeFormulaData: jest.fn(),
+			handleQueryFunctionsUpdates: jest.fn(),
+			listOfAdditionalFormulaFilters: [],
+		});
+	});
+
+	afterEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('renders limit input when dataSource is logs', () => {
+		const baseQuery: IBuilderQuery = {
+			queryName: 'A',
+			dataSource: DataSource.LOGS,
+			aggregateOperator: '',
+			aggregations: [],
+			timeAggregation: '',
+			spaceAggregation: '',
+			temporality: '',
+			functions: [],
+			filter: undefined,
+			filters: { items: [], op: 'AND' },
+			groupBy: [],
+			expression: '',
+			disabled: false,
+			having: [] as Having[],
+			limit: 10,
+			stepInterval: null,
+			orderBy: [],
+			legend: 'A',
+		};
+
+		render(
+			<QueryV2
+				index={0}
+				isAvailableToDisable
+				query={baseQuery}
+				version="v4"
+				onSignalSourceChange={jest.fn() as jest.MockedFunction<(v: string) => void>}
+				signalSourceChangeEnabled={false}
+				queriesCount={1}
+				showTraceOperator={false}
+				hasTraceOperator={false}
+			/>,
+		);
+
+		// Ensure the Limit add-on input is present and is of type number
+		const limitInput = screen.getByPlaceholderText(
+			'Enter limit',
+		) as HTMLInputElement;
+		expect(limitInput).toBeInTheDocument();
+		expect(limitInput).toHaveAttribute('type', 'number');
+		expect(limitInput).toHaveAttribute('name', 'limit');
+		expect(limitInput).toHaveAttribute('data-testid', 'input-Limit');
+	});
+});

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

@@ -1,6 +1,12 @@
 /* eslint-disable */
-import { fireEvent, render, screen } from '@testing-library/react';
-import React from 'react';
+import {
+	fireEvent,
+	render,
+	screen,
+	userEvent,
+	waitFor,
+	within,
+} from 'tests/test-utils';
 
 import QueryAddOns from '../QueryV2/QueryAddOns/QueryAddOns';
 import { PANEL_TYPES } from 'constants/queryBuilder';
@@ -55,16 +61,7 @@ jest.mock('../QueryV2/QueryAddOns/HavingFilter/HavingFilter', () => ({
 	),
 }));
 
-jest.mock(
-	'container/QueryBuilder/filters/ReduceToFilter/ReduceToFilter',
-	() => ({
-		ReduceToFilter: ({ onChange }: any) => (
-			<button data-testid="reduce-to" onClick={() => onChange('sum')}>
-				ReduceToFilter
-			</button>
-		),
-	}),
-);
+// ReduceToFilter is not mocked - we test the actual Ant Design Select component
 
 function baseQuery(overrides: Partial<any> = {}): any {
 	return {
@@ -140,7 +137,7 @@ describe('QueryAddOns', () => {
 		expect(screen.getByTestId('order-by-content')).toBeInTheDocument();
 	});
 
-	it('limit input auto-opens when limit is set and changing it calls handler', () => {
+	it('limit input auto-opens when limit is set and changing it calls handler', async () => {
 		render(
 			<QueryAddOns
 				query={baseQuery({ limit: 5 })}
@@ -183,4 +180,88 @@ describe('QueryAddOns', () => {
 		expect(screen.getByTestId('limit-content')).toBeInTheDocument();
 		expect(limitInput.value).toBe('7');
 	});
+
+	it('shows reduce-to add-on when showReduceTo is true', () => {
+		render(
+			<QueryAddOns
+				query={baseQuery()}
+				version="v5"
+				isListViewPanel={false}
+				showReduceTo
+				panelType={PANEL_TYPES.TIME_SERIES}
+				index={0}
+				isForTraceOperator={false}
+			/>,
+		);
+
+		expect(screen.getByTestId('query-add-on-reduce_to')).toBeInTheDocument();
+	});
+
+	it('auto-opens reduce-to content when reduceTo is set', () => {
+		render(
+			<QueryAddOns
+				query={baseQuery({ reduceTo: 'sum' })}
+				version="v5"
+				isListViewPanel={false}
+				showReduceTo
+				panelType={PANEL_TYPES.TIME_SERIES}
+				index={0}
+				isForTraceOperator={false}
+			/>,
+		);
+
+		expect(screen.getByTestId('reduce-to-content')).toBeInTheDocument();
+	});
+
+	it('calls handleSetQueryData when reduce-to value changes', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		const query = baseQuery({
+			reduceTo: 'avg',
+			aggregations: [{ id: 'a', operator: 'count', reduceTo: 'avg' }],
+		});
+		render(
+			<QueryAddOns
+				query={query}
+				version="v5"
+				isListViewPanel={false}
+				showReduceTo
+				panelType={PANEL_TYPES.TIME_SERIES}
+				index={0}
+				isForTraceOperator={false}
+			/>,
+		);
+
+		// Wait for the reduce-to content section to be visible (it auto-opens when reduceTo is set)
+		await waitFor(() => {
+			expect(screen.getByTestId('reduce-to-content')).toBeInTheDocument();
+		});
+
+		// Get the Select component by its role (combobox)
+		// The Select is within the reduce-to-content section
+		const reduceToContent = screen.getByTestId('reduce-to-content');
+		const selectCombobox = within(reduceToContent).getByRole('combobox');
+
+		// Open the dropdown by clicking on the combobox
+		await user.click(selectCombobox);
+
+		// Wait for the dropdown listbox to appear
+		await screen.findByRole('listbox');
+
+		// Find and click the "Sum" option
+		const sumOption = await screen.findByText('Sum of values in timeframe');
+		await user.click(sumOption);
+
+		// Verify the handler was called with the correct value
+		await waitFor(() => {
+			expect(mockHandleSetQueryData).toHaveBeenCalledWith(0, {
+				...query,
+				aggregations: [
+					{
+						...(query.aggregations?.[0] as any),
+						reduceTo: 'sum',
+					},
+				],
+			});
+		});
+	});
 });

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/Checkbox.tsx

@@ -421,11 +421,16 @@ export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 										...currentFilter,
 										value: currentFilter.value.filter((val) => val !== value),
 									};
-
 									if (newFilter.value.length === 0) {
 										query.filters.items = query.filters.items.filter(
 											(item) => !isEqual(item.key?.key, filter.attributeKey.key),
 										);
+										if (query.filter?.expression) {
+											query.filter.expression = removeKeysFromExpression(
+												query.filter.expression,
+												[filter.attributeKey.key],
+											);
+										}
 									} else {
 										query.filters.items = query.filters.items.map((item) => {
 											if (isEqual(item.key?.key, filter.attributeKey.key)) {
@@ -435,6 +440,16 @@ export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 										});
 									}
 								} else {
+									const newFilter = {
+										...currentFilter,
+										value: currentFilter.value === value ? null : currentFilter.value,
+									};
+									if (newFilter.value === null && query.filter?.expression) {
+										query.filter.expression = removeKeysFromExpression(
+											query.filter.expression,
+											[filter.attributeKey.key],
+										);
+									}
 									query.filters.items = query.filters.items.filter(
 										(item) => !isEqual(item.key?.key, filter.attributeKey.key),
 									);
@@ -612,7 +627,7 @@ export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 											) : (
 												<Typography.Text
 													className="value-string"
-													ellipsis={{ tooltip: { placement: 'right' } }}
+													ellipsis={{ tooltip: { placement: 'top' } }}
 												>
 													{String(value)}
 												</Typography.Text>

frontend/src/components/YAxisUnitSelector/YAxisUnitSelector.tsx

@@ -1,11 +1,18 @@
 import './styles.scss';
 
-import { Select } from 'antd';
+import { WarningFilled } from '@ant-design/icons';
+import { Select, Tooltip } from 'antd';
 import { DefaultOptionType } from 'antd/es/select';
+import classNames from 'classnames';
+import { useMemo } from 'react';
 
 import { UniversalYAxisUnitMappings } from './constants';
 import { UniversalYAxisUnit, YAxisUnitSelectorProps } from './types';
-import { getYAxisCategories, mapMetricUnitToUniversalUnit } from './utils';
+import {
+	getUniversalNameFromMetricUnit,
+	getYAxisCategories,
+	mapMetricUnitToUniversalUnit,
+} from './utils';
 
 function YAxisUnitSelector({
 	value,
@@ -14,9 +21,24 @@ function YAxisUnitSelector({
 	loading = false,
 	'data-testid': dataTestId,
 	source,
+	initialValue,
 }: YAxisUnitSelectorProps): JSX.Element {
 	const universalUnit = mapMetricUnitToUniversalUnit(value);
 
+	const incompatibleUnitMessage = useMemo(() => {
+		if (!initialValue || !value || loading) return '';
+		const initialUniversalUnit = mapMetricUnitToUniversalUnit(initialValue);
+		const currentUniversalUnit = mapMetricUnitToUniversalUnit(value);
+		if (initialUniversalUnit !== currentUniversalUnit) {
+			const initialUniversalUnitName = getUniversalNameFromMetricUnit(
+				initialValue,
+			);
+			const currentUniversalUnitName = getUniversalNameFromMetricUnit(value);
+			return `Unit mismatch. Saved unit is ${initialUniversalUnitName}, but ${currentUniversalUnitName} is selected.`;
+		}
+		return '';
+	}, [initialValue, value, loading]);
+
 	const handleSearch = (
 		searchTerm: string,
 		currentOption: DefaultOptionType | undefined,
@@ -49,6 +71,16 @@ function YAxisUnitSelector({
 				placeholder={placeholder}
 				filterOption={(input, option): boolean => handleSearch(input, option)}
 				loading={loading}
+				suffixIcon={
+					incompatibleUnitMessage ? (
+						<Tooltip title={incompatibleUnitMessage}>
+							<WarningFilled />
+						</Tooltip>
+					) : undefined
+				}
+				className={classNames({
+					'warning-state': incompatibleUnitMessage,
+				})}
 				data-testid={dataTestId}
 			>
 				{categories.map((category) => (

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

@@ -91,4 +91,36 @@ describe('YAxisUnitSelector', () => {
 		expect(screen.getByText('Bytes (B)')).toBeInTheDocument();
 		expect(screen.getByText('Seconds (s)')).toBeInTheDocument();
 	});
+
+	it('shows warning message when incompatible unit is selected', () => {
+		render(
+			<YAxisUnitSelector
+				source={YAxisSource.ALERTS}
+				value="By"
+				onChange={mockOnChange}
+				initialValue="s"
+			/>,
+		);
+		const warningIcon = screen.getByLabelText('warning');
+		expect(warningIcon).toBeInTheDocument();
+		fireEvent.mouseOver(warningIcon);
+		return screen
+			.findByText(
+				'Unit mismatch. Saved unit is Seconds (s), but Bytes (B) is selected.',
+			)
+			.then((el) => expect(el).toBeInTheDocument());
+	});
+
+	it('does not show warning message when compatible unit is selected', () => {
+		render(
+			<YAxisUnitSelector
+				source={YAxisSource.ALERTS}
+				value="s"
+				onChange={mockOnChange}
+				initialValue="s"
+			/>,
+		);
+		const warningIcon = screen.queryByLabelText('warning');
+		expect(warningIcon).not.toBeInTheDocument();
+	});
 });

frontend/src/components/YAxisUnitSelector/styles.scss

@@ -3,3 +3,13 @@
 		width: 220px;
 	}
 }
+
+.warning-state {
+	.ant-select-selector {
+		border-color: var(--bg-amber-400) !important;
+	}
+
+	.anticon {
+		color: var(--bg-amber-400) !important;
+	}
+}

frontend/src/components/YAxisUnitSelector/types.ts

@@ -6,6 +6,7 @@ export interface YAxisUnitSelectorProps {
 	disabled?: boolean;
 	'data-testid'?: string;
 	source: YAxisSource;
+	initialValue?: string;
 }
 
 export enum UniversalYAxisUnit {

frontend/src/constants/app.ts

@@ -1,5 +1,7 @@
 import ROUTES from './routes';
 
+export const DOCS_BASE_URL = process.env.DOCS_BASE_URL || 'https://signoz.io';
+
 export const WITHOUT_SESSION_PATH = ['/redirect'];
 
 export const AUTH0_REDIRECT_PATH = '/redirect';

frontend/src/constants/queryFunctionOptions.ts

@@ -68,8 +68,8 @@ export const metricQueryFunctionOptions: SelectOption<string, string>[] = [
 		label: 'Time Shift',
 	},
 	{
-		value: QueryFunctionsTypes.TIME_SHIFT,
-		label: 'Time Shift',
+		value: QueryFunctionsTypes.FILL_ZERO,
+		label: 'Fill Zero',
 	},
 ];
 
@@ -156,4 +156,7 @@ export const queryFunctionsTypesConfig: QueryFunctionConfigType = {
 		showInput: true,
 		inputType: 'text',
 	},
+	fillZero: {
+		showInput: false,
+	},
 };

frontend/src/constants/reactQueryKeys.ts

@@ -55,6 +55,7 @@ export const REACT_QUERY_KEY = {
 	GET_METRIC_DETAILS: 'GET_METRIC_DETAILS',
 	GET_RELATED_METRICS: 'GET_RELATED_METRICS',
 	GET_INSPECT_METRICS_DETAILS: 'GET_INSPECT_METRICS_DETAILS',
+	GET_METRIC_METADATA: 'GET_METRIC_METADATA',
 
 	// Traces Funnels Query Keys
 	GET_DOMAINS_LIST: 'GET_DOMAINS_LIST',

frontend/src/container/ApiMonitoring/utils.tsx

@@ -3123,7 +3123,7 @@ export const getAllEndpointsWidgetData = (
 	return widget;
 };
 
-const keysToRemove = ['http.url', 'url.full', 'B', 'C', 'F1'];
+const keysToRemove = ['http.url', 'url.full', 'A', 'B', 'C', 'F1'];
 
 export const getGroupByFiltersFromGroupByValues = (
 	rowData: any,

frontend/src/container/CreateAlertV2/QuerySection/ChartPreview/ChartPreview.tsx

@@ -5,9 +5,11 @@ import { useCreateAlertState } from 'container/CreateAlertV2/context';
 import ChartPreviewComponent from 'container/FormAlertRules/ChartPreview';
 import PlotTag from 'container/NewWidget/LeftContainer/WidgetGraph/PlotTag';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { useState } from 'react';
+import useGetYAxisUnit from 'hooks/useGetYAxisUnit';
+import { useEffect, useState } from 'react';
 import { useSelector } from 'react-redux';
 import { AppState } from 'store/reducers';
+import { AlertTypes } from 'types/api/alerts/alertTypes';
 import { AlertDef } from 'types/api/alerts/def';
 import { EQueryType } from 'types/common/dashboard';
 import { GlobalReducer } from 'types/reducer/globalTime';
@@ -18,7 +20,13 @@ export interface ChartPreviewProps {
 
 function ChartPreview({ alertDef }: ChartPreviewProps): JSX.Element {
 	const { currentQuery, panelType, stagedQuery } = useQueryBuilder();
-	const { thresholdState, alertState, setAlertState } = useCreateAlertState();
+	const {
+		alertType,
+		thresholdState,
+		alertState,
+		setAlertState,
+		isEditMode,
+	} = useCreateAlertState();
 	const { selectedTime: globalSelectedInterval } = useSelector<
 		AppState,
 		GlobalReducer
@@ -27,6 +35,25 @@ function ChartPreview({ alertDef }: ChartPreviewProps): JSX.Element {
 
 	const yAxisUnit = alertState.yAxisUnit || '';
 
+	const fetchYAxisUnit =
+		!isEditMode && alertType === AlertTypes.METRICS_BASED_ALERT;
+
+	const selectedQueryName = thresholdState.selectedQuery;
+	const { yAxisUnit: initialYAxisUnit, isLoading } = useGetYAxisUnit(
+		selectedQueryName,
+		{
+			enabled: fetchYAxisUnit,
+		},
+	);
+
+	// Every time a new metric is selected, set the y-axis unit to its unit value if present
+	// Only for metrics-based alerts
+	useEffect(() => {
+		if (fetchYAxisUnit) {
+			setAlertState({ type: 'SET_Y_AXIS_UNIT', payload: initialYAxisUnit });
+		}
+	}, [initialYAxisUnit, setAlertState, fetchYAxisUnit]);
+
 	const headline = (
 		<div className="chart-preview-headline">
 			<PlotTag
@@ -34,11 +61,13 @@ function ChartPreview({ alertDef }: ChartPreviewProps): JSX.Element {
 				panelType={panelType || PANEL_TYPES.TIME_SERIES}
 			/>
 			<YAxisUnitSelector
-				value={alertState.yAxisUnit}
+				value={yAxisUnit}
+				initialValue={initialYAxisUnit}
 				onChange={(value): void => {
 					setAlertState({ type: 'SET_Y_AXIS_UNIT', payload: value });
 				}}
 				source={YAxisSource.ALERTS}
+				loading={isLoading}
 			/>
 		</div>
 	);

frontend/src/container/GridCardLayout/GridCard/FullView/index.tsx

@@ -120,7 +120,6 @@ function FullView({
 				originalGraphType: selectedPanelType,
 			};
 		}
-		updatedQuery.builder.queryData[0].pageSize = 10;
 		return {
 			query: updatedQuery,
 			graphType: PANEL_TYPES.LIST,

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

@@ -137,7 +137,6 @@ function GridCardGraph({
 				originalGraphType: widget.panelTypes,
 			};
 		}
-		updatedQuery.builder.queryData[0].pageSize = 10;
 		const initialDataSource = updatedQuery.builder.queryData[0].dataSource;
 		return {
 			query: updatedQuery,

frontend/src/container/GridCardLayout/WidgetHeader/__tests__/WidgetHeader.test.tsx

@@ -24,6 +24,8 @@ const TABLE_WIDGET_TITLE = 'Table Widget';
 const WIDGET_HEADER_SEARCH = 'widget-header-search';
 const WIDGET_HEADER_SEARCH_INPUT = 'widget-header-search-input';
 const TEST_WIDGET_TITLE_RESOLVED = 'Test Widget Title';
+const CREATE_ALERTS_TEXT = 'Create Alerts';
+const WIDGET_HEADER_OPTIONS_ID = 'widget-header-options';
 
 const mockStore = configureStore([thunk]);
 const createMockStore = (): ReturnType<typeof mockStore> =>
@@ -101,6 +103,9 @@ jest.mock('lucide-react', () => ({
 	CircleX: (): JSX.Element => <svg data-testid="lucide-circle-x" />,
 	TriangleAlert: (): JSX.Element => <svg data-testid="lucide-triangle-alert" />,
 	X: (): JSX.Element => <svg data-testid="lucide-x" />,
+	SquareArrowOutUpRight: (): JSX.Element => (
+		<svg data-testid="lucide-square-arrow-out-up-right" />
+	),
 }));
 jest.mock('antd', () => ({
 	...jest.requireActual('antd'),
@@ -391,7 +396,7 @@ describe('WidgetHeader', () => {
 			/>,
 		);
 
-		const moreOptionsIcon = screen.getByTestId('widget-header-options');
+		const moreOptionsIcon = screen.getByTestId(WIDGET_HEADER_OPTIONS_ID);
 		expect(moreOptionsIcon).toBeInTheDocument();
 	});
 
@@ -455,4 +460,66 @@ describe('WidgetHeader', () => {
 
 		expect(screen.getByTestId('threshold')).toBeInTheDocument();
 	});
+
+	describe('Create Alerts Menu Item', () => {
+		it('renders Create Alerts menu item with external link icon when included in headerMenuList', async () => {
+			render(
+				<WidgetHeader
+					title={TEST_WIDGET_TITLE}
+					widget={mockWidget}
+					onView={mockOnView}
+					queryResponse={mockQueryResponse}
+					isWarning={false}
+					isFetchingResponse={false}
+					tableProcessedDataRef={tableProcessedDataRef}
+					setSearchTerm={mockSetSearchTerm}
+					headerMenuList={[MenuItemKeys.CreateAlerts]}
+				/>,
+			);
+
+			const moreOptionsIcon = await screen.findByTestId(WIDGET_HEADER_OPTIONS_ID);
+			expect(moreOptionsIcon).toBeInTheDocument();
+			await userEvent.hover(moreOptionsIcon);
+
+			await screen.findByText(CREATE_ALERTS_TEXT);
+
+			const externalLinkIcon = await screen.findByTestId(
+				'lucide-square-arrow-out-up-right',
+			);
+			expect(externalLinkIcon).toBeInTheDocument();
+		});
+
+		it('Create Alerts menu item is enabled and clickable', async () => {
+			const mockCreateAlertsHandler = jest.fn();
+			const useCreateAlerts = jest.requireMock(
+				'hooks/queryBuilder/useCreateAlerts',
+			).default;
+			useCreateAlerts.mockReturnValue(mockCreateAlertsHandler);
+
+			render(
+				<WidgetHeader
+					title={TEST_WIDGET_TITLE}
+					widget={mockWidget}
+					onView={mockOnView}
+					queryResponse={mockQueryResponse}
+					isWarning={false}
+					isFetchingResponse={false}
+					tableProcessedDataRef={tableProcessedDataRef}
+					setSearchTerm={mockSetSearchTerm}
+					headerMenuList={[MenuItemKeys.CreateAlerts]}
+				/>,
+			);
+
+			expect(useCreateAlerts).toHaveBeenCalledWith(mockWidget, 'dashboardView');
+
+			const moreOptionsIcon = await screen.findByTestId(WIDGET_HEADER_OPTIONS_ID);
+			await userEvent.hover(moreOptionsIcon);
+
+			const createAlertsMenuItem = await screen.findByText(CREATE_ALERTS_TEXT);
+
+			// Verify the menu item is clickable by actually clicking it
+			await userEvent.click(createAlertsMenuItem);
+			expect(mockCreateAlertsHandler).toHaveBeenCalledTimes(1);
+		});
+	});
 });

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

@@ -26,7 +26,7 @@ import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { RowData } from 'lib/query/createTableColumnsFromQuery';
 import { isEmpty } from 'lodash-es';
-import { CircleX, X } from 'lucide-react';
+import { CircleX, SquareArrowOutUpRight, X } from 'lucide-react';
 import { unparse } from 'papaparse';
 import { useAppContext } from 'providers/App/App';
 import { ReactNode, useCallback, useMemo, useState } from 'react';
@@ -185,7 +185,18 @@ function WidgetHeader({
 			{
 				key: MenuItemKeys.CreateAlerts,
 				icon: <AlertOutlined />,
-				label: MENUITEM_KEYS_VS_LABELS[MenuItemKeys.CreateAlerts],
+				label: (
+					<span
+						style={{
+							display: 'flex',
+							alignItems: 'baseline',
+							justifyContent: 'space-between',
+						}}
+					>
+						{MENUITEM_KEYS_VS_LABELS[MenuItemKeys.CreateAlerts]}
+						<SquareArrowOutUpRight size={10} />
+					</span>
+				),
 				isVisible: headerMenuList?.includes(MenuItemKeys.CreateAlerts) || false,
 				disabled: false,
 			},

frontend/src/container/GridCardLayout/WidgetHeader/types.ts

@@ -5,7 +5,7 @@ import { MenuItemKeys } from './contants';
 export interface MenuItem {
 	key: MenuItemKeys;
 	icon: ReactNode;
-	label: string;
+	label: ReactNode;
 	isVisible: boolean;
 	disabled: boolean;
 	danger?: boolean;

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

@@ -996,6 +996,7 @@
 		gap: 8px;
 		justify-content: space-between;
 		align-items: center;
+		width: 100%;
 
 		.ingestion-key-url-label {
 			font-size: 13px;
@@ -1057,6 +1058,26 @@
 	}
 }
 
+.ingestion-url-error-tooltip {
+	.ingestion-url-error-content {
+		display: flex;
+		flex-direction: column;
+		gap: 8px;
+	}
+
+	.ingestion-url-error-code {
+		font-size: 12px;
+		font-weight: 500;
+		color: var(--bg-amber-500);
+	}
+
+	.ingestion-url-error-message {
+		font-size: 12px;
+		font-weight: 400;
+		color: var(--bg-vanilla-300);
+	}
+}
+
 .lightMode {
 	.ingestion-setup-details-links {
 		background: rgba(113, 144, 249, 0.1);
@@ -1066,4 +1087,16 @@
 			color: var(--bg-robin-500);
 		}
 	}
+
+	.ingestion-url-error-tooltip {
+		.ingestion-url-error-content {
+			.ingestion-url-error-code {
+				color: var(--bg-amber-500);
+			}
+		}
+
+		.ingestion-url-error-message {
+			color: var(--bg-ink-500);
+		}
+	}
 }

frontend/src/container/IngestionSettings/MultiIngestionSettings.tsx

@@ -40,10 +40,9 @@ import { initialQueryMeterWithType } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
 import { INITIAL_ALERT_THRESHOLD_STATE } from 'container/CreateAlertV2/context/constants';
 import dayjs from 'dayjs';
-import { useGetDeploymentsData } from 'hooks/CustomDomain/useGetDeploymentsData';
+import { useGetGlobalConfig } from 'hooks/globalConfig/useGetGlobalConfig';
 import { useGetAllIngestionsKeys } from 'hooks/IngestionKeys/useGetAllIngestionKeys';
 import useDebouncedFn from 'hooks/useDebouncedFunction';
-import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { useNotifications } from 'hooks/useNotifications';
 import { cloneDeep, isNil, isUndefined } from 'lodash-es';
 import {
@@ -59,11 +58,12 @@ import {
 	PlusIcon,
 	Search,
 	Trash2,
+	TriangleAlert,
 	X,
 } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
 import { useTimezone } from 'providers/Timezone';
-import { ChangeEvent, useEffect, useState } from 'react';
+import { ChangeEvent, useCallback, useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useMutation } from 'react-query';
 import { useHistory } from 'react-router-dom';
@@ -176,8 +176,6 @@ function MultiIngestionSettings(): JSX.Element {
 
 	const [totalIngestionKeys, setTotalIngestionKeys] = useState(0);
 
-	const { isEnterpriseSelfHostedUser } = useGetTenantLicense();
-
 	const history = useHistory();
 
 	const [
@@ -302,11 +300,11 @@ function MultiIngestionSettings(): JSX.Element {
 	};
 
 	const {
-		data: deploymentsData,
-		isLoading: isLoadingDeploymentsData,
-		isFetching: isFetchingDeploymentsData,
-		isError: isErrorDeploymentsData,
-	} = useGetDeploymentsData(!isEnterpriseSelfHostedUser);
+		data: globalConfig,
+		isLoading: isLoadingGlobalConfig,
+		isError: isErrorGlobalConfig,
+		error: globalConfigError,
+	} = useGetGlobalConfig();
 
 	const {
 		mutate: createIngestionKey,
@@ -448,12 +446,15 @@ function MultiIngestionSettings(): JSX.Element {
 			});
 	};
 
-	const handleCopyKey = (text: string): void => {
-		handleCopyToClipboard(text);
-		notifications.success({
-			message: 'Copied to clipboard',
-		});
-	};
+	const handleCopyKey = useCallback(
+		(text: string): void => {
+			handleCopyToClipboard(text);
+			notifications.success({
+				message: 'Copied to clipboard',
+			});
+		},
+		[handleCopyToClipboard, notifications],
+	);
 
 	const gbToBytes = (gb: number): number => Math.round(gb * 1024 ** 3);
 
@@ -1391,6 +1392,19 @@ function MultiIngestionSettings(): JSX.Element {
 		});
 	};
 
+	const handleCopyIngestionURL = useCallback(
+		(e: React.MouseEvent<HTMLDivElement>): void => {
+			e.stopPropagation();
+			e.preventDefault();
+
+			const ingestionURL = globalConfig?.data?.ingestion_url;
+			if (ingestionURL) {
+				handleCopyKey(ingestionURL);
+			}
+		},
+		[globalConfig, handleCopyKey],
+	);
+
 	return (
 		<div className="ingestion-key-container">
 			<div className="ingestion-key-content">
@@ -1409,46 +1423,44 @@ function MultiIngestionSettings(): JSX.Element {
 					</Typography.Text>
 				</header>
 
-				{!isErrorDeploymentsData &&
-					!isLoadingDeploymentsData &&
-					!isFetchingDeploymentsData &&
-					deploymentsData && (
-						<div className="ingestion-setup-details-links">
-							<div className="ingestion-key-url-container">
-								<div className="ingestion-key-url-label">Ingestion URL</div>
+				{!isLoadingGlobalConfig && (
+					<div className="ingestion-setup-details-links">
+						<div className="ingestion-key-url-container">
+							<div className="ingestion-key-url-label">Ingestion URL</div>
+
+							{!isErrorGlobalConfig && (
 								<div
 									className="ingestion-key-url-value"
-									onClick={(e): void => {
-										e.stopPropagation();
-										e.preventDefault();
-										handleCopyKey(
-											`ingest.${deploymentsData?.data.data.cluster.region.dns}`,
-										);
-									}}
+									onClick={handleCopyIngestionURL}
 								>
-									ingest.{deploymentsData?.data.data.cluster.region.dns}
+									{globalConfig?.data.ingestion_url}
 									<Copy className="copy-key-btn" size={12} />
 								</div>
-							</div>
+							)}
 
-							<div className="ingestion-data-region-container">
-								<div className="ingestion-data-region-label">Region</div>
-								<div
-									className="ingestion-data-region-value"
-									onClick={(e): void => {
-										e.stopPropagation();
-										e.preventDefault();
-										handleCopyKey(deploymentsData?.data.data.cluster.region.name || '');
-									}}
+							{isErrorGlobalConfig && (
+								<Tooltip
+									rootClassName="ingestion-url-error-tooltip"
+									arrow={false}
+									title={
+										<div className="ingestion-url-error-content">
+											<Typography.Text className="ingestion-url-error-code">
+												{globalConfigError?.getErrorCode()}
+											</Typography.Text>
+
+											<Typography.Text className="ingestion-url-error-message">
+												{globalConfigError?.getErrorMessage()}
+											</Typography.Text>
+										</div>
+									}
+									placement="topLeft"
 								>
-									<Typography.Text className="ingestion-data-region-value-text">
-										{deploymentsData?.data.data.cluster.region.name}
-									</Typography.Text>
-									<Copy className="copy-key-btn" size={12} />
-								</div>
-							</div>
+									<Button type="text" icon={<TriangleAlert size={14} />} />
+								</Tooltip>
+							)}
 						</div>
-					)}
+					</div>
+				)}
 
 				<div className="ingestion-keys-search-add-new">
 					<Input

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

@@ -219,7 +219,7 @@ export default function TableViewActions(
 				/>
 				{!isListViewPanel && !RESTRICTED_SELECTED_FIELDS.includes(fieldFilterKey) && (
 					<span className="action-btn">
-						<Tooltip title="Filter for value">
+						<Tooltip title="Filter for value" mouseLeaveDelay={0}>
 							<Button
 								className="filter-btn periscope-btn"
 								icon={
@@ -238,7 +238,7 @@ export default function TableViewActions(
 								)}
 							/>
 						</Tooltip>
-						<Tooltip title="Filter out value">
+						<Tooltip title="Filter out value" mouseLeaveDelay={0}>
 							<Button
 								className="filter-btn periscope-btn"
 								icon={
@@ -299,7 +299,7 @@ export default function TableViewActions(
 			</CopyClipboardHOC>
 			{!isListViewPanel && !RESTRICTED_SELECTED_FIELDS.includes(fieldFilterKey) && (
 				<span className="action-btn">
-					<Tooltip title="Filter for value">
+					<Tooltip title="Filter for value" mouseLeaveDelay={0}>
 						<Button
 							className="filter-btn periscope-btn"
 							icon={
@@ -318,7 +318,7 @@ export default function TableViewActions(
 							)}
 						/>
 					</Tooltip>
-					<Tooltip title="Filter out value">
+					<Tooltip title="Filter out value" mouseLeaveDelay={0}>
 						<Button
 							className="filter-btn periscope-btn"
 							icon={

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

@@ -35,7 +35,7 @@ jest.mock('providers/preferences/sync/usePreferenceSync', () => ({
 		preferences: {
 			columns: [],
 			formatting: {
-				maxLines: 2,
+				maxLines: 1,
 				format: 'table',
 				fontSize: 'small',
 				version: 1,

frontend/src/container/LogsExplorerViews/tests/LogsExplorerViews.test.tsx

@@ -119,7 +119,7 @@ jest.mock('providers/preferences/sync/usePreferenceSync', () => ({
 		preferences: {
 			columns: [],
 			formatting: {
-				maxLines: 2,
+				maxLines: 1,
 				format: 'table',
 				fontSize: 'small',
 				version: 1,

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

@@ -58,6 +58,27 @@
 	.explore-content {
 		padding: 0 8px;
 
+		.y-axis-unit-selector-container {
+			display: flex;
+			align-items: center;
+			gap: 10px;
+			padding-top: 10px;
+			margin-bottom: 10px;
+
+			.save-unit-container {
+				display: flex;
+				align-items: center;
+				gap: 10px;
+
+				.ant-btn {
+					border-radius: 2px;
+					.ant-typography {
+						font-size: 12px;
+					}
+				}
+			}
+		}
+
 		.ant-space {
 			margin-top: 10px;
 			margin-bottom: 20px;
@@ -75,6 +96,14 @@
 		.time-series-view {
 			min-width: 100%;
 			width: 100%;
+			position: relative;
+
+			.no-unit-warning {
+				position: absolute;
+				top: 30px;
+				right: 40px;
+				z-index: 1000;
+			}
 		}
 
 		.time-series-container {

frontend/src/container/MetricsExplorer/Explorer/Explorer.tsx

@@ -1,7 +1,7 @@
 import './Explorer.styles.scss';
 
 import * as Sentry from '@sentry/react';
-import { Switch } from 'antd';
+import { Switch, Tooltip } from 'antd';
 import logEvent from 'api/common/logEvent';
 import { QueryBuilderV2 } from 'components/QueryBuilderV2/QueryBuilderV2';
 import WarningPopover from 'components/WarningPopover/WarningPopover';
@@ -25,10 +25,14 @@ import { generateExportToDashboardLink } from 'utils/dashboard/generateExportToD
 import { v4 as uuid } from 'uuid';
 
 import { MetricsExplorerEventKeys, MetricsExplorerEvents } from '../events';
-// import QuerySection from './QuerySection';
+import MetricDetails from '../MetricDetails/MetricDetails';
 import TimeSeries from './TimeSeries';
 import { ExplorerTabs } from './types';
-import { splitQueryIntoOneChartPerQuery } from './utils';
+import {
+	getMetricUnits,
+	splitQueryIntoOneChartPerQuery,
+	useGetMetrics,
+} from './utils';
 
 const ONE_CHART_PER_QUERY_ENABLED_KEY = 'isOneChartPerQueryEnabled';
 
@@ -40,6 +44,34 @@ function Explorer(): JSX.Element {
 		currentQuery,
 	} = useQueryBuilder();
 	const { safeNavigate } = useSafeNavigate();
+	const [isMetricDetailsOpen, setIsMetricDetailsOpen] = useState(false);
+
+	const metricNames = useMemo(() => {
+		const currentMetricNames: string[] = [];
+		stagedQuery?.builder.queryData.forEach((query) => {
+			if (query.aggregateAttribute?.key) {
+				currentMetricNames.push(query.aggregateAttribute?.key);
+			}
+		});
+		return currentMetricNames;
+	}, [stagedQuery]);
+
+	const {
+		metrics,
+		isLoading: isMetricUnitsLoading,
+		isError: isMetricUnitsError,
+	} = useGetMetrics(metricNames);
+
+	const units = useMemo(() => getMetricUnits(metrics), [metrics]);
+
+	const areAllMetricUnitsSame = useMemo(
+		() =>
+			!isMetricUnitsLoading &&
+			!isMetricUnitsError &&
+			units.length > 0 &&
+			units.every((unit) => unit && unit === units[0]),
+		[units, isMetricUnitsLoading, isMetricUnitsError],
+	);
 
 	const [searchParams, setSearchParams] = useSearchParams();
 	const isOneChartPerQueryEnabled =
@@ -48,7 +80,66 @@ function Explorer(): JSX.Element {
 	const [showOneChartPerQuery, toggleShowOneChartPerQuery] = useState(
 		isOneChartPerQueryEnabled,
 	);
+	const [disableOneChartPerQuery, toggleDisableOneChartPerQuery] = useState(
+		false,
+	);
 	const [selectedTab] = useState<ExplorerTabs>(ExplorerTabs.TIME_SERIES);
+	const [yAxisUnit, setYAxisUnit] = useState<string | undefined>();
+
+	const unitsLength = useMemo(() => units.length, [units]);
+	const firstUnit = useMemo(() => units?.[0], [units]);
+
+	useEffect(() => {
+		// Set the y axis unit to the first metric unit if
+		// 1. There is one metric unit and it is not empty
+		// 2. All metric units are the same and not empty
+		// Else, set the y axis unit to empty if
+		// 1. There are more than one metric units and they are not the same
+		// 2. There are no metric units
+		// 3. There is exactly one metric unit but it is empty/undefined
+		if (unitsLength === 0) {
+			setYAxisUnit(undefined);
+		} else if (unitsLength === 1 && firstUnit) {
+			setYAxisUnit(firstUnit);
+		} else if (unitsLength === 1 && !firstUnit) {
+			setYAxisUnit(undefined);
+		} else if (areAllMetricUnitsSame) {
+			if (firstUnit) {
+				setYAxisUnit(firstUnit);
+			} else {
+				setYAxisUnit(undefined);
+			}
+		} else if (unitsLength > 1 && !areAllMetricUnitsSame) {
+			setYAxisUnit(undefined);
+		}
+	}, [unitsLength, firstUnit, areAllMetricUnitsSame]);
+
+	useEffect(() => {
+		// Don't apply logic during loading to avoid overwriting user preferences
+		if (isMetricUnitsLoading) {
+			return;
+		}
+
+		// Disable one chart per query if -
+		// 1. There are more than one metric
+		// 2. The metric units are not the same
+		if (units.length > 1 && !areAllMetricUnitsSame) {
+			toggleShowOneChartPerQuery(true);
+			toggleDisableOneChartPerQuery(true);
+		} else if (units.length <= 1) {
+			toggleShowOneChartPerQuery(false);
+			toggleDisableOneChartPerQuery(true);
+		} else {
+			// When units are the same and loading is complete, restore URL-based preference
+			toggleShowOneChartPerQuery(isOneChartPerQueryEnabled);
+			toggleDisableOneChartPerQuery(false);
+		}
+	}, [
+		units,
+		areAllMetricUnitsSame,
+		isMetricUnitsLoading,
+		isOneChartPerQueryEnabled,
+	]);
 
 	const handleToggleShowOneChartPerQuery = (): void => {
 		toggleShowOneChartPerQuery(!showOneChartPerQuery);
@@ -68,15 +159,20 @@ function Explorer(): JSX.Element {
 		[updateAllQueriesOperators],
 	);
 
-	const exportDefaultQuery = useMemo(
-		() =>
-			updateAllQueriesOperators(
-				currentQuery || initialQueriesMap[DataSource.METRICS],
-				PANEL_TYPES.TIME_SERIES,
-				DataSource.METRICS,
-			),
-		[currentQuery, updateAllQueriesOperators],
-	);
+	const exportDefaultQuery = useMemo(() => {
+		const query = updateAllQueriesOperators(
+			currentQuery || initialQueriesMap[DataSource.METRICS],
+			PANEL_TYPES.TIME_SERIES,
+			DataSource.METRICS,
+		);
+		if (yAxisUnit && !query.unit) {
+			return {
+				...query,
+				unit: yAxisUnit,
+			};
+		}
+		return query;
+	}, [currentQuery, updateAllQueriesOperators, yAxisUnit]);
 
 	useShareBuilderUrl({ defaultValue: defaultQuery });
 
@@ -90,8 +186,16 @@ function Explorer(): JSX.Element {
 
 			const widgetId = uuid();
 
+			let query = queryToExport || exportDefaultQuery;
+			if (yAxisUnit && !query.unit) {
+				query = {
+					...query,
+					unit: yAxisUnit,
+				};
+			}
+
 			const dashboardEditView = generateExportToDashboardLink({
-				query: queryToExport || exportDefaultQuery,
+				query,
 				panelType: PANEL_TYPES.TIME_SERIES,
 				dashboardId: dashboard.id,
 				widgetId,
@@ -99,17 +203,33 @@ function Explorer(): JSX.Element {
 
 			safeNavigate(dashboardEditView);
 		},
-		[exportDefaultQuery, safeNavigate],
+		[exportDefaultQuery, safeNavigate, yAxisUnit],
 	);
 
 	const splitedQueries = useMemo(
 		() =>
 			splitQueryIntoOneChartPerQuery(
 				stagedQuery || initialQueriesMap[DataSource.METRICS],
+				metricNames,
+				units,
 			),
-		[stagedQuery],
+		[stagedQuery, metricNames, units],
 	);
 
+	const [selectedMetricName, setSelectedMetricName] = useState<string | null>(
+		null,
+	);
+
+	const handleOpenMetricDetails = (metricName: string): void => {
+		setIsMetricDetailsOpen(true);
+		setSelectedMetricName(metricName);
+	};
+
+	const handleCloseMetricDetails = (): void => {
+		setIsMetricDetailsOpen(false);
+		setSelectedMetricName(null);
+	};
+
 	useEffect(() => {
 		logEvent(MetricsExplorerEvents.TabChanged, {
 			[MetricsExplorerEventKeys.Tab]: 'explorer',
@@ -123,17 +243,44 @@ function Explorer(): JSX.Element {
 
 	const [warning, setWarning] = useState<Warning | undefined>(undefined);
 
+	const oneChartPerQueryDisabledTooltip = useMemo(() => {
+		if (splitedQueries.length <= 1) {
+			return 'One chart per query cannot be toggled for a single query.';
+		}
+		if (units.length <= 1) {
+			return 'One chart per query cannot be toggled when there is only one metric.';
+		}
+		if (disableOneChartPerQuery) {
+			return 'One chart per query cannot be disabled for multiple queries with different units.';
+		}
+		return undefined;
+	}, [disableOneChartPerQuery, splitedQueries.length, units.length]);
+
+	// Show the y axis unit selector if -
+	// 1. There is only one metric
+	// 2. The metric has no saved unit
+	const showYAxisUnitSelector = useMemo(
+		() => !isMetricUnitsLoading && units.length === 1 && !units[0],
+		[units, isMetricUnitsLoading],
+	);
+
 	return (
 		<Sentry.ErrorBoundary fallback={<ErrorBoundaryFallback />}>
 			<div className="metrics-explorer-explore-container">
 				<div className="explore-header">
 					<div className="explore-header-left-actions">
 						<span>1 chart/query</span>
-						<Switch
-							checked={showOneChartPerQuery}
-							onChange={handleToggleShowOneChartPerQuery}
-							size="small"
-						/>
+						<Tooltip
+							open={disableOneChartPerQuery ? undefined : false}
+							title={oneChartPerQueryDisabledTooltip}
+						>
+							<Switch
+								checked={showOneChartPerQuery}
+								onChange={handleToggleShowOneChartPerQuery}
+								disabled={disableOneChartPerQuery || splitedQueries.length <= 1}
+								size="small"
+							/>
+						</Tooltip>
 					</div>
 					<div className="explore-header-right-actions">
 						{!isEmpty(warning) && <WarningPopover warningData={warning} />}
@@ -174,6 +321,16 @@ function Explorer(): JSX.Element {
 						<TimeSeries
 							showOneChartPerQuery={showOneChartPerQuery}
 							setWarning={setWarning}
+							areAllMetricUnitsSame={areAllMetricUnitsSame}
+							isMetricUnitsLoading={isMetricUnitsLoading}
+							isMetricUnitsError={isMetricUnitsError}
+							metricUnits={units}
+							metricNames={metricNames}
+							metrics={metrics}
+							handleOpenMetricDetails={handleOpenMetricDetails}
+							yAxisUnit={yAxisUnit}
+							setYAxisUnit={setYAxisUnit}
+							showYAxisUnitSelector={showYAxisUnitSelector}
 						/>
 					)}
 					{/* TODO: Enable once we have resolved all related metrics issues */}
@@ -187,9 +344,17 @@ function Explorer(): JSX.Element {
 				query={exportDefaultQuery}
 				sourcepage={DataSource.METRICS}
 				onExport={handleExport}
-				isOneChartPerQuery={false}
+				isOneChartPerQuery={showOneChartPerQuery}
 				splitedQueries={splitedQueries}
 			/>
+			{isMetricDetailsOpen && (
+				<MetricDetails
+					metricName={selectedMetricName}
+					isOpen={isMetricDetailsOpen}
+					onClose={handleCloseMetricDetails}
+					isModalTimeSelection={false}
+				/>
+			)}
 		</Sentry.ErrorBoundary>
 	);
 }

frontend/src/container/MetricsExplorer/Explorer/TimeSeries.tsx

@@ -1,14 +1,18 @@
+import { Color } from '@signozhq/design-tokens';
+import { Tooltip, Typography } from 'antd';
 import { isAxiosError } from 'axios';
 import classNames from 'classnames';
+import YAxisUnitSelector from 'components/YAxisUnitSelector';
+import { YAxisSource } from 'components/YAxisUnitSelector/types';
 import { ENTITY_VERSION_V5 } from 'constants/app';
 import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
 import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import { BuilderUnitsFilter } from 'container/QueryBuilder/filters/BuilderUnitsFilter/BuilderUnits';
 import TimeSeriesView from 'container/TimeSeriesView/TimeSeriesView';
 import { convertDataValueToMs } from 'container/TimeSeriesView/utils';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
-import { useMemo, useState } from 'react';
+import { AlertTriangle } from 'lucide-react';
+import { useMemo } from 'react';
 import { useQueries } from 'react-query';
 import { useSelector } from 'react-redux';
 import { AppState } from 'store/reducers';
@@ -24,6 +28,13 @@ import { splitQueryIntoOneChartPerQuery } from './utils';
 function TimeSeries({
 	showOneChartPerQuery,
 	setWarning,
+	isMetricUnitsLoading,
+	metricUnits,
+	metricNames,
+	handleOpenMetricDetails,
+	yAxisUnit,
+	setYAxisUnit,
+	showYAxisUnitSelector,
 }: TimeSeriesProps): JSX.Element {
 	const { stagedQuery, currentQuery } = useQueryBuilder();
 
@@ -56,13 +67,14 @@ function TimeSeries({
 			showOneChartPerQuery
 				? splitQueryIntoOneChartPerQuery(
 						stagedQuery || initialQueriesMap[DataSource.METRICS],
+						metricNames,
+						metricUnits,
 				  )
 				: [stagedQuery || initialQueriesMap[DataSource.METRICS]],
-		[showOneChartPerQuery, stagedQuery],
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+		[showOneChartPerQuery, stagedQuery, JSON.stringify(metricUnits)],
 	);
 
-	const [yAxisUnit, setYAxisUnit] = useState<string>('');
-
 	const queries = useQueries(
 		queryPayloads.map((payload, index) => ({
 			queryKey: [
@@ -126,32 +138,148 @@ function TimeSeries({
 		setYAxisUnit(value);
 	};
 
+	// TODO: Enable once we have resolved all related metrics v2 api issues
+	// Show the save unit button if
+	// 1. There is only one metric
+	// 2. The metric has no saved unit
+	// 3. The user has selected a unit
+	// const showSaveUnitButton = useMemo(
+	// 	() =>
+	// 		metricUnits.length === 1 &&
+	// 		Boolean(metrics?.[0]) &&
+	// 		!metricUnits[0] &&
+	// 		yAxisUnit,
+	// 	[metricUnits, metrics, yAxisUnit],
+	// );
+
+	// const {
+	// 	mutate: updateMetricMetadata,
+	// 	isLoading: isUpdatingMetricMetadata,
+	// } = useUpdateMetricMetadata();
+
+	// const handleSaveUnit = (): void => {
+	// 	updateMetricMetadata(
+	// 		{
+	// 			metricName: metricNames[0],
+	// 			payload: {
+	// 				unit: yAxisUnit,
+	// 				description: metrics[0]?.description ?? '',
+	// 				metricType: metrics[0]?.type as MetricType,
+	// 				temporality: metrics[0]?.temporality,
+	// 			},
+	// 		},
+	// 		{
+	// 			onSuccess: () => {
+	// 				notifications.success({
+	// 					message: 'Unit saved successfully',
+	// 				});
+	// 				queryClient.invalidateQueries([
+	// 					REACT_QUERY_KEY.GET_METRIC_DETAILS,
+	// 					metricNames[0],
+	// 				]);
+	// 			},
+	// 			onError: () => {
+	// 				notifications.error({
+	// 					message: 'Failed to save unit',
+	// 				});
+	// 			},
+	// 		},
+	// 	);
+	// };
+
 	return (
 		<>
-			<BuilderUnitsFilter onChange={onUnitChangeHandler} yAxisUnit={yAxisUnit} />
+			<div className="y-axis-unit-selector-container">
+				{showYAxisUnitSelector && (
+					<>
+						<YAxisUnitSelector
+							onChange={onUnitChangeHandler}
+							value={yAxisUnit}
+							source={YAxisSource.EXPLORER}
+							data-testid="y-axis-unit-selector"
+						/>
+						{/* TODO: Enable once we have resolved all related metrics v2 api issues */}
+						{/* {showSaveUnitButton && (
+							<div className="save-unit-container">
+								<Typography.Text>
+									Save the selected unit for this metric?
+								</Typography.Text>
+								<Button
+									type="primary"
+									size="small"
+									disabled={isUpdatingMetricMetadata}
+									onClick={handleSaveUnit}
+								>
+									<Typography.Paragraph>Yes</Typography.Paragraph>
+								</Button>
+							</div>
+						)} */}
+					</>
+				)}
+			</div>
 			<div
 				className={classNames({
 					'time-series-container': changeLayoutForOneChartPerQuery,
 				})}
 			>
-				{responseData.map((datapoint, index) => (
-					<div
-						className="time-series-view"
-						// eslint-disable-next-line react/no-array-index-key
-						key={index}
-					>
-						<TimeSeriesView
-							isFilterApplied={false}
-							isError={queries[index].isError}
-							isLoading={queries[index].isLoading}
-							data={datapoint}
-							yAxisUnit={yAxisUnit}
-							dataSource={DataSource.METRICS}
-							error={queries[index].error as APIError}
-							setWarning={setWarning}
-						/>
-					</div>
-				))}
+				{responseData.map((datapoint, index) => {
+					const isQueryDataItem = index < metricNames.length;
+					const metricName = isQueryDataItem ? metricNames[index] : undefined;
+					const metricUnit = isQueryDataItem ? metricUnits[index] : undefined;
+
+					// Show the no unit warning if -
+					// 1. The metric query is not loading
+					// 2. The metric units are not loading
+					// 3. There are more than one metric
+					// 4. The current metric unit is empty
+					// 5. Is a queryData item
+					const isMetricUnitEmpty =
+						isQueryDataItem &&
+						!queries[index].isLoading &&
+						!isMetricUnitsLoading &&
+						metricUnits.length > 1 &&
+						!metricUnit &&
+						metricName;
+
+					const currentYAxisUnit = yAxisUnit || metricUnit;
+
+					return (
+						<div
+							className="time-series-view"
+							// eslint-disable-next-line react/no-array-index-key
+							key={index}
+						>
+							{isMetricUnitEmpty && metricName && (
+								<Tooltip
+									className="no-unit-warning"
+									title={
+										<Typography.Text>
+											This metric does not have a unit. Please set one for it in the{' '}
+											<Typography.Link
+												onClick={(): void => handleOpenMetricDetails(metricName)}
+											>
+												metric details
+											</Typography.Link>{' '}
+											page.
+										</Typography.Text>
+									}
+								>
+									<AlertTriangle size={16} color={Color.BG_AMBER_400} />
+								</Tooltip>
+							)}
+							<TimeSeriesView
+								isFilterApplied={false}
+								isError={queries[index].isError}
+								isLoading={queries[index].isLoading || isMetricUnitsLoading}
+								data={datapoint}
+								yAxisUnit={currentYAxisUnit}
+								dataSource={DataSource.METRICS}
+								error={queries[index].error as APIError}
+								setWarning={setWarning}
+							/>
+						</div>
+					);
+				})}
 			</div>
 		</>
 	);

frontend/src/container/MetricsExplorer/Explorer/__tests__/Explorer.test.tsx

@@ -1,4 +1,6 @@
 import { render, screen } from '@testing-library/react';
+import { Temporality } from 'api/metricsExplorer/getMetricDetails';
+import { MetricType } from 'api/metricsExplorer/getMetricsList';
 import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
 import * as useOptionsMenuHooks from 'container/OptionsMenu';
 import * as useUpdateDashboardHooks from 'hooks/dashboard/useUpdateDashboard';
@@ -12,13 +14,18 @@ import { MemoryRouter } from 'react-router-dom';
 import { useSearchParams } from 'react-router-dom-v5-compat';
 import store from 'store';
 import { LicenseEvent } from 'types/api/licensesV3/getActive';
-import { DataSource } from 'types/common/queryBuilder';
+import { MetricMetadata } from 'types/api/metricsExplorer/v2/getMetricMetadata';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { DataSource, QueryBuilderContextType } from 'types/common/queryBuilder';
 
 import Explorer from '../Explorer';
+import * as useGetMetricsHooks from '../utils';
 
 const mockSetSearchParams = jest.fn();
 const queryClient = new QueryClient();
-const mockUpdateAllQueriesOperators = jest.fn();
+const mockUpdateAllQueriesOperators = jest
+	.fn()
+	.mockReturnValue(initialQueriesMap[DataSource.METRICS]);
 const mockUseQueryBuilderData = {
 	handleRunQuery: jest.fn(),
 	stagedQuery: initialQueriesMap[DataSource.METRICS],
@@ -126,6 +133,30 @@ jest.spyOn(useQueryBuilderHooks, 'useQueryBuilder').mockReturnValue({
 	...mockUseQueryBuilderData,
 } as any);
 
+const Y_AXIS_UNIT_SELECTOR_TEST_ID = 'y-axis-unit-selector';
+
+const mockMetric: MetricMetadata = {
+	type: MetricType.SUM,
+	description: 'metric1 description',
+	unit: 'metric1 unit',
+	temporality: Temporality.CUMULATIVE,
+	isMonotonic: true,
+};
+
+function renderExplorer(): void {
+	render(
+		<QueryClientProvider client={queryClient}>
+			<MemoryRouter>
+				<Provider store={store}>
+					<ErrorModalProvider>
+						<Explorer />
+					</ErrorModalProvider>
+				</Provider>
+			</MemoryRouter>
+		</QueryClientProvider>,
+	);
+}
+
 describe('Explorer', () => {
 	beforeEach(() => {
 		jest.clearAllMocks();
@@ -142,17 +173,7 @@ describe('Explorer', () => {
 			mockSetSearchParams,
 		]);
 
-		render(
-			<QueryClientProvider client={queryClient}>
-				<MemoryRouter>
-					<Provider store={store}>
-						<ErrorModalProvider>
-							<Explorer />
-						</ErrorModalProvider>
-					</Provider>
-				</MemoryRouter>
-			</QueryClientProvider>,
-		);
+		renderExplorer();
 
 		expect(mockUpdateAllQueriesOperators).toHaveBeenCalledWith(
 			initialQueriesMap[DataSource.METRICS],
@@ -166,18 +187,13 @@ describe('Explorer', () => {
 			new URLSearchParams({ isOneChartPerQueryEnabled: 'true' }),
 			mockSetSearchParams,
 		]);
+		jest.spyOn(useGetMetricsHooks, 'useGetMetrics').mockReturnValue({
+			isLoading: false,
+			isError: false,
+			metrics: [mockMetric, mockMetric],
+		});
 
-		render(
-			<QueryClientProvider client={queryClient}>
-				<MemoryRouter>
-					<Provider store={store}>
-						<ErrorModalProvider>
-							<Explorer />
-						</ErrorModalProvider>
-					</Provider>
-				</MemoryRouter>
-			</QueryClientProvider>,
-		);
+		renderExplorer();
 
 		const toggle = screen.getByRole('switch');
 		expect(toggle).toBeChecked();
@@ -188,20 +204,132 @@ describe('Explorer', () => {
 			new URLSearchParams({ isOneChartPerQueryEnabled: 'false' }),
 			mockSetSearchParams,
 		]);
+		jest.spyOn(useGetMetricsHooks, 'useGetMetrics').mockReturnValue({
+			isLoading: false,
+			isError: false,
+			metrics: [mockMetric, mockMetric],
+		});
 
-		render(
-			<QueryClientProvider client={queryClient}>
-				<MemoryRouter>
-					<Provider store={store}>
-						<ErrorModalProvider>
-							<Explorer />
-						</ErrorModalProvider>
-					</Provider>
-				</MemoryRouter>
-			</QueryClientProvider>,
-		);
+		renderExplorer();
 
 		const toggle = screen.getByRole('switch');
 		expect(toggle).not.toBeChecked();
 	});
+
+	it('should not render y axis unit selector for single metric which has a unit', () => {
+		jest.spyOn(useGetMetricsHooks, 'useGetMetrics').mockReturnValue({
+			isLoading: false,
+			isError: false,
+			metrics: [mockMetric],
+		});
+
+		renderExplorer();
+
+		const yAxisUnitSelector = screen.queryByTestId(Y_AXIS_UNIT_SELECTOR_TEST_ID);
+		expect(yAxisUnitSelector).not.toBeInTheDocument();
+	});
+
+	it('should not render y axis unit selector for mutliple metrics with same unit', () => {
+		(useSearchParams as jest.Mock).mockReturnValueOnce([
+			new URLSearchParams({ isOneChartPerQueryEnabled: 'true' }),
+			mockSetSearchParams,
+		]);
+		jest.spyOn(useGetMetricsHooks, 'useGetMetrics').mockReturnValue({
+			isLoading: false,
+			isError: false,
+			metrics: [mockMetric, mockMetric],
+		});
+
+		renderExplorer();
+
+		const yAxisUnitSelector = screen.queryByTestId(Y_AXIS_UNIT_SELECTOR_TEST_ID);
+		expect(yAxisUnitSelector).not.toBeInTheDocument();
+	});
+
+	it('should hide y axis unit selector for multiple metrics with different units', () => {
+		jest.spyOn(useGetMetricsHooks, 'useGetMetrics').mockReturnValue({
+			isLoading: false,
+			isError: false,
+			metrics: [mockMetric, mockMetric],
+		});
+
+		renderExplorer();
+
+		const yAxisUnitSelector = screen.queryByTestId(Y_AXIS_UNIT_SELECTOR_TEST_ID);
+		expect(yAxisUnitSelector).not.toBeInTheDocument();
+
+		// One chart per query toggle should be disabled
+		const oneChartPerQueryToggle = screen.getByRole('switch');
+		expect(oneChartPerQueryToggle).toBeDisabled();
+	});
+
+	it('should render empty y axis unit selector for a single metric with no unit', () => {
+		jest.spyOn(useGetMetricsHooks, 'useGetMetrics').mockReturnValue({
+			isLoading: false,
+			isError: false,
+			metrics: [
+				{
+					type: MetricType.SUM,
+					description: 'metric1 description',
+					unit: '',
+					temporality: Temporality.CUMULATIVE,
+					isMonotonic: true,
+				},
+			],
+		});
+
+		renderExplorer();
+
+		const yAxisUnitSelector = screen.queryByTestId(Y_AXIS_UNIT_SELECTOR_TEST_ID);
+		expect(yAxisUnitSelector).toBeInTheDocument();
+		expect(yAxisUnitSelector).toHaveTextContent('Please select a unit');
+	});
+
+	it('one chart per query should be off and disabled when there is only one query', () => {
+		jest.spyOn(useGetMetricsHooks, 'useGetMetrics').mockReturnValue({
+			isLoading: false,
+			isError: false,
+			metrics: [mockMetric],
+		});
+
+		renderExplorer();
+
+		const oneChartPerQueryToggle = screen.getByRole('switch');
+		expect(oneChartPerQueryToggle).not.toBeChecked();
+		expect(oneChartPerQueryToggle).toBeDisabled();
+	});
+
+	it('one chart per query should enabled by default when there are multiple metrics with the same unit', () => {
+		const mockQueryData = {
+			...initialQueriesMap[DataSource.METRICS].builder.queryData[0],
+			aggregateAttribute: {
+				...(initialQueriesMap[DataSource.METRICS].builder.queryData[0]
+					.aggregateAttribute as BaseAutocompleteData),
+				key: 'metric1',
+			},
+		};
+		const mockStagedQueryWithMultipleQueries = {
+			...initialQueriesMap[DataSource.METRICS],
+			builder: {
+				...initialQueriesMap[DataSource.METRICS].builder,
+				queryData: [mockQueryData, mockQueryData],
+			},
+		};
+
+		jest.spyOn(useQueryBuilderHooks, 'useQueryBuilder').mockReturnValue(({
+			...mockUseQueryBuilderData,
+			stagedQuery: mockStagedQueryWithMultipleQueries,
+		} as Partial<QueryBuilderContextType>) as QueryBuilderContextType);
+
+		jest.spyOn(useGetMetricsHooks, 'useGetMetrics').mockReturnValue({
+			isLoading: false,
+			isError: false,
+			metrics: [mockMetric, mockMetric],
+		});
+
+		renderExplorer();
+
+		const oneChartPerQueryToggle = screen.getByRole('switch');
+		expect(oneChartPerQueryToggle).toBeEnabled();
+	});
 });

frontend/src/container/MetricsExplorer/Explorer/__tests__/TimeSeries.test.tsx

@@ -0,0 +1,180 @@
+import { render, RenderResult, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { Temporality } from 'api/metricsExplorer/getMetricDetails';
+import { MetricType } from 'api/metricsExplorer/getMetricsList';
+import { UpdateMetricMetadataResponse } from 'api/metricsExplorer/updateMetricMetadata';
+import * as useUpdateMetricMetadataHooks from 'hooks/metricsExplorer/useUpdateMetricMetadata';
+import { UseUpdateMetricMetadataProps } from 'hooks/metricsExplorer/useUpdateMetricMetadata';
+import { UseMutationResult } from 'react-query';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { MetricMetadata } from 'types/api/metricsExplorer/v2/getMetricMetadata';
+
+import TimeSeries from '../TimeSeries';
+import { TimeSeriesProps } from '../types';
+
+type MockUpdateMetricMetadata = UseMutationResult<
+	SuccessResponse<UpdateMetricMetadataResponse> | ErrorResponse,
+	Error,
+	UseUpdateMetricMetadataProps
+>;
+const mockUpdateMetricMetadata = jest.fn();
+jest
+	.spyOn(useUpdateMetricMetadataHooks, 'useUpdateMetricMetadata')
+	.mockReturnValue(({
+		mutate: mockUpdateMetricMetadata,
+		isLoading: false,
+	} as Partial<MockUpdateMetricMetadata>) as MockUpdateMetricMetadata);
+
+jest.mock('container/TimeSeriesView/TimeSeriesView', () => ({
+	__esModule: true,
+	default: jest.fn().mockReturnValue(
+		<div role="img" aria-label="warning">
+			TimeSeriesView
+		</div>,
+	),
+}));
+
+jest.mock('react-query', () => ({
+	...jest.requireActual('react-query'),
+	useQueryClient: jest.fn().mockReturnValue({
+		invalidateQueries: jest.fn(),
+	}),
+	useQueries: jest.fn().mockImplementation((queries: any[]) =>
+		queries.map(() => ({
+			data: undefined,
+			isLoading: false,
+			isError: false,
+			error: undefined,
+		})),
+	),
+}));
+
+jest.mock('react-redux', () => ({
+	...jest.requireActual('react-redux'),
+	useSelector: jest.fn().mockReturnValue({
+		globalTime: {
+			selectedTime: '5min',
+			maxTime: 1713738000000,
+			minTime: 1713734400000,
+		},
+	}),
+}));
+
+const mockMetric: MetricMetadata = {
+	type: MetricType.SUM,
+	description: 'metric1 description',
+	unit: 'metric1 unit',
+	temporality: Temporality.CUMULATIVE,
+	isMonotonic: true,
+};
+
+const mockSetWarning = jest.fn();
+const mockSetIsMetricDetailsOpen = jest.fn();
+const mockSetYAxisUnit = jest.fn();
+
+function renderTimeSeries(
+	overrides: Partial<TimeSeriesProps> = {},
+): RenderResult {
+	return render(
+		<TimeSeries
+			showOneChartPerQuery={false}
+			setWarning={mockSetWarning}
+			areAllMetricUnitsSame={false}
+			isMetricUnitsLoading={false}
+			metricUnits={[]}
+			metricNames={[]}
+			metrics={[]}
+			isMetricUnitsError={false}
+			handleOpenMetricDetails={mockSetIsMetricDetailsOpen}
+			yAxisUnit="count"
+			setYAxisUnit={mockSetYAxisUnit}
+			showYAxisUnitSelector={false}
+			// eslint-disable-next-line react/jsx-props-no-spreading
+			{...overrides}
+		/>,
+	);
+}
+
+describe('TimeSeries', () => {
+	it('should render a warning icon when a metric has no unit among multiple metrics', () => {
+		const user = userEvent.setup();
+		const { container } = renderTimeSeries({
+			metricUnits: ['', 'count'],
+			metricNames: ['metric1', 'metric2'],
+			metrics: [undefined, undefined],
+		});
+
+		const alertIcon = container.querySelector('.no-unit-warning') as HTMLElement;
+		user.hover(alertIcon);
+		waitFor(() =>
+			expect(
+				screen.findByText('This metric does not have a unit'),
+			).toBeInTheDocument(),
+		);
+	});
+
+	it('clicking on warning icon tooltip should open metric details modal', async () => {
+		const user = userEvent.setup();
+		const { container } = renderTimeSeries({
+			metricUnits: ['', 'count'],
+			metricNames: ['metric1', 'metric2'],
+			metrics: [mockMetric, mockMetric],
+			yAxisUnit: 'seconds',
+		});
+
+		const alertIcon = container.querySelector('.no-unit-warning') as HTMLElement;
+		user.hover(alertIcon);
+
+		const metricDetailsLink = await screen.findByText('metric details');
+		user.click(metricDetailsLink);
+
+		waitFor(() =>
+			expect(mockSetIsMetricDetailsOpen).toHaveBeenCalledWith('metric1'),
+		);
+	});
+
+	// TODO: Unskip this test once the save unit button is implemented
+	// Tracking at - https://github.com/SigNoz/engineering-pod/issues/3495
+	it.skip('shows Save unit button when metric had no unit but one is selected', () => {
+		const { findByText, getByRole } = renderTimeSeries({
+			metricUnits: [undefined],
+			metricNames: ['metric1'],
+			metrics: [mockMetric],
+			yAxisUnit: 'seconds',
+		});
+
+		expect(
+			findByText('Save the selected unit for this metric?'),
+		).toBeInTheDocument();
+
+		const yesButton = getByRole('button', { name: 'Yes' });
+		expect(yesButton).toBeInTheDocument();
+		expect(yesButton).toBeEnabled();
+	});
+
+	// TODO: Unskip this test once the save unit button is implemented
+	// Tracking at - https://github.com/SigNoz/engineering-pod/issues/3495
+	it.skip('clicking on save unit button shoould upated metric metadata', () => {
+		const user = userEvent.setup();
+		const { getByRole } = renderTimeSeries({
+			metricUnits: [''],
+			metricNames: ['metric1'],
+			metrics: [mockMetric],
+			yAxisUnit: 'seconds',
+		});
+
+		const yesButton = getByRole('button', { name: /Yes/i });
+		user.click(yesButton);
+
+		expect(mockUpdateMetricMetadata).toHaveBeenCalledWith(
+			{
+				metricName: 'metric1',
+				payload: expect.objectContaining({ unit: 'seconds' }),
+			},
+			expect.objectContaining({
+				onSuccess: expect.any(Function),
+				onError: expect.any(Function),
+			}),
+		);
+	});
+});

frontend/src/container/MetricsExplorer/Explorer/__tests__/utils.test.tsx

@@ -0,0 +1,161 @@
+import { renderHook } from '@testing-library/react';
+import { Temporality } from 'api/metricsExplorer/getMetricDetails';
+import { MetricType } from 'api/metricsExplorer/getMetricsList';
+import { initialQueriesMap } from 'constants/queryBuilder';
+import * as useGetMultipleMetricsHook from 'hooks/metricsExplorer/useGetMultipleMetrics';
+import { UseQueryResult } from 'react-query';
+import { SuccessResponseV2 } from 'types/api';
+import {
+	MetricMetadata,
+	MetricMetadataResponse,
+} from 'types/api/metricsExplorer/v2/getMetricMetadata';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import {
+	IBuilderFormula,
+	IBuilderQuery,
+	Query,
+} from 'types/api/queryBuilder/queryBuilderData';
+import { DataSource } from 'types/common/queryBuilder';
+
+import {
+	getMetricUnits,
+	splitQueryIntoOneChartPerQuery,
+	useGetMetrics,
+} from '../utils';
+
+const MOCK_QUERY_DATA_1: IBuilderQuery = {
+	...initialQueriesMap[DataSource.METRICS].builder.queryData[0],
+	aggregateAttribute: {
+		...(initialQueriesMap[DataSource.METRICS].builder.queryData[0]
+			.aggregateAttribute as BaseAutocompleteData),
+		key: 'metric1',
+	},
+};
+
+const MOCK_QUERY_DATA_2: IBuilderQuery = {
+	...initialQueriesMap[DataSource.METRICS].builder.queryData[0],
+	aggregateAttribute: {
+		...(initialQueriesMap[DataSource.METRICS].builder.queryData[0]
+			.aggregateAttribute as BaseAutocompleteData),
+		key: 'metric2',
+	},
+};
+const MOCK_FORMULA_DATA: IBuilderFormula = {
+	expression: '1 + 1',
+	disabled: false,
+	queryName: 'Mock Formula',
+	legend: 'Mock Legend',
+};
+
+const MOCK_QUERY_WITH_MULTIPLE_QUERY_DATA: Query = {
+	...initialQueriesMap[DataSource.METRICS],
+	builder: {
+		...initialQueriesMap[DataSource.METRICS].builder,
+		queryData: [MOCK_QUERY_DATA_1, MOCK_QUERY_DATA_2],
+		queryFormulas: [MOCK_FORMULA_DATA, MOCK_FORMULA_DATA],
+	},
+};
+
+describe('splitQueryIntoOneChartPerQuery', () => {
+	it('should split a query with multiple queryData to multiple distinct queries, each with a single queryData', () => {
+		const result = splitQueryIntoOneChartPerQuery(
+			MOCK_QUERY_WITH_MULTIPLE_QUERY_DATA,
+			['metric1', 'metric2'],
+			[undefined, 'unit2'],
+		);
+		expect(result).toHaveLength(4);
+		// Verify query 1 has the correct data
+		expect(result[0].builder.queryData).toHaveLength(1);
+		expect(result[0].builder.queryData[0]).toEqual(MOCK_QUERY_DATA_1);
+		expect(result[0].builder.queryFormulas).toHaveLength(0);
+		expect(result[0].unit).toBeUndefined();
+		// Verify query 2 has the correct data
+		expect(result[1].builder.queryData).toHaveLength(1);
+		expect(result[1].builder.queryData[0]).toEqual(MOCK_QUERY_DATA_2);
+		expect(result[1].builder.queryFormulas).toHaveLength(0);
+		expect(result[1].unit).toBe('unit2');
+		// Verify query 3 has the correct data
+		expect(result[2].builder.queryFormulas).toHaveLength(1);
+		expect(result[2].builder.queryFormulas[0]).toEqual(MOCK_FORMULA_DATA);
+		expect(result[2].builder.queryData).toHaveLength(2); // 2 disabled queries
+		expect(result[2].builder.queryData[0].disabled).toBe(true);
+		expect(result[2].builder.queryData[1].disabled).toBe(true);
+		expect(result[2].unit).toBeUndefined();
+		// Verify query 4 has the correct data
+		expect(result[3].builder.queryFormulas).toHaveLength(1);
+		expect(result[3].builder.queryFormulas[0]).toEqual(MOCK_FORMULA_DATA);
+		expect(result[3].builder.queryData).toHaveLength(2); // 2 disabled queries
+		expect(result[3].builder.queryData[0].disabled).toBe(true);
+		expect(result[3].builder.queryData[1].disabled).toBe(true);
+		expect(result[3].unit).toBeUndefined();
+	});
+});
+
+const MOCK_METRIC_METADATA: MetricMetadata = {
+	description: 'Metric 1 description',
+	unit: 'unit1',
+	type: MetricType.GAUGE,
+	temporality: Temporality.DELTA,
+	isMonotonic: true,
+};
+
+describe('useGetMetrics', () => {
+	beforeEach(() => {
+		jest
+			.spyOn(useGetMultipleMetricsHook, 'useGetMultipleMetrics')
+			.mockReturnValue([
+				({
+					isLoading: false,
+					isError: false,
+					data: {
+						httpStatusCode: 200,
+						data: {
+							status: 'success',
+							data: MOCK_METRIC_METADATA,
+						},
+					},
+				} as Partial<
+					UseQueryResult<SuccessResponseV2<MetricMetadataResponse>, Error>
+				>) as UseQueryResult<SuccessResponseV2<MetricMetadataResponse>, Error>,
+			]);
+	});
+
+	it('should return the correct metrics data', () => {
+		const { result } = renderHook(() => useGetMetrics(['metric1']));
+		expect(result.current.metrics).toHaveLength(1);
+		expect(result.current.metrics[0]).toBeDefined();
+		expect(result.current.metrics[0]).toEqual(MOCK_METRIC_METADATA);
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.isError).toBe(false);
+	});
+
+	it('should return array of undefined values of correct length when metrics data is not yet loaded', () => {
+		jest
+			.spyOn(useGetMultipleMetricsHook, 'useGetMultipleMetrics')
+			.mockReturnValue([
+				({
+					isLoading: true,
+					isError: false,
+				} as Partial<
+					UseQueryResult<SuccessResponseV2<MetricMetadataResponse>, Error>
+				>) as UseQueryResult<SuccessResponseV2<MetricMetadataResponse>, Error>,
+			]);
+		const { result } = renderHook(() => useGetMetrics(['metric1']));
+		expect(result.current.metrics).toHaveLength(1);
+		expect(result.current.metrics[0]).toBeUndefined();
+	});
+});
+
+describe('getMetricUnits', () => {
+	it('should return the same unit for units that are not known to the universal unit mapper', () => {
+		const result = getMetricUnits([MOCK_METRIC_METADATA]);
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual(MOCK_METRIC_METADATA.unit);
+	});
+
+	it('should return universal unit for units that are known to the universal unit mapper', () => {
+		const result = getMetricUnits([{ ...MOCK_METRIC_METADATA, unit: 'seconds' }]);
+		expect(result).toHaveLength(1);
+		expect(result[0]).toBe('s');
+	});
+});

frontend/src/container/MetricsExplorer/Explorer/types.ts

@@ -3,6 +3,7 @@ import { Dispatch, SetStateAction } from 'react';
 import { UseQueryResult } from 'react-query';
 import { SuccessResponse, Warning } from 'types/api';
 import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
+import { MetricMetadata } from 'types/api/metricsExplorer/v2/getMetricMetadata';
 
 export enum ExplorerTabs {
 	TIME_SERIES = 'time-series',
@@ -12,6 +13,16 @@ export enum ExplorerTabs {
 export interface TimeSeriesProps {
 	showOneChartPerQuery: boolean;
 	setWarning: Dispatch<SetStateAction<Warning | undefined>>;
+	areAllMetricUnitsSame: boolean;
+	isMetricUnitsLoading: boolean;
+	isMetricUnitsError: boolean;
+	metricUnits: (string | undefined)[];
+	metricNames: string[];
+	metrics: (MetricMetadata | undefined)[];
+	handleOpenMetricDetails: (metricName: string) => void;
+	yAxisUnit: string | undefined;
+	setYAxisUnit: (unit: string) => void;
+	showYAxisUnitSelector: boolean;
 }
 
 export interface RelatedMetricsProps {

frontend/src/container/MetricsExplorer/Explorer/utils.tsx

@@ -1,20 +1,40 @@
+import { mapMetricUnitToUniversalUnit } from 'components/YAxisUnitSelector/utils';
+import { useGetMultipleMetrics } from 'hooks/metricsExplorer/useGetMultipleMetrics';
+import { MetricMetadata } from 'types/api/metricsExplorer/v2/getMetricMetadata';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 import { v4 as uuid } from 'uuid';
 
-export const splitQueryIntoOneChartPerQuery = (query: Query): Query[] => {
+/**
+ * Split a query with multiple queryData to multiple distinct queries, each with a single queryData.
+ * @param query - The query to split
+ * @param units - The units of the metrics, can be undefined if the metric has no unit
+ * @returns The split queries
+ */
+export const splitQueryIntoOneChartPerQuery = (
+	query: Query,
+	metricNames: string[],
+	units: (string | undefined)[],
+): Query[] => {
 	const queries: Query[] = [];
 
 	query.builder.queryData.forEach((currentQuery) => {
-		const newQuery = {
-			...query,
-			id: uuid(),
-			builder: {
-				...query.builder,
-				queryData: [currentQuery],
-				queryFormulas: [],
-			},
-		};
-		queries.push(newQuery);
+		if (currentQuery.aggregateAttribute?.key) {
+			const metricIndex = metricNames.indexOf(
+				currentQuery.aggregateAttribute?.key,
+			);
+			const unit = metricIndex >= 0 ? units[metricIndex] : undefined;
+			const newQuery = {
+				...query,
+				id: uuid(),
+				builder: {
+					...query.builder,
+					queryData: [currentQuery],
+					queryFormulas: [],
+				},
+				unit,
+			};
+			queries.push(newQuery);
+		}
 	});
 
 	query.builder.queryFormulas.forEach((currentFormula) => {
@@ -35,3 +55,43 @@ export const splitQueryIntoOneChartPerQuery = (query: Query): Query[] => {
 
 	return queries;
 };
+
+/**
+ * Hook to get data for multiple metrics with a synchronous loading and error state
+ * @param metricNames - The names of the metrics to get
+ * @param isEnabled - Whether the hook is enabled
+ * @returns The loading state, the metrics data, and the error state
+ */
+export function useGetMetrics(
+	metricNames: string[],
+	isEnabled = true,
+): {
+	isLoading: boolean;
+	isError: boolean;
+	metrics: (MetricMetadata | undefined)[];
+} {
+	const metricsData = useGetMultipleMetrics(metricNames, {
+		enabled: metricNames.length > 0 && isEnabled,
+	});
+	return {
+		isLoading: metricsData.some((metric) => metric.isLoading),
+		metrics: metricsData
+			.map((metric) => metric.data?.data)
+			.map((data) => data?.data),
+		isError: metricsData.some((metric) => metric.isError),
+	};
+}
+
+/**
+ * To get the units of the metrics in the universal unit standard.
+ * If the unit is not known to the universal unit mapper, it will return the unit as is.
+ * @param metrics - The metrics to get the units for
+ * @returns The units of the metrics, can be undefined if the metric has no unit
+ */
+export function getMetricUnits(
+	metrics: (MetricMetadata | undefined)[],
+): (string | undefined)[] {
+	return metrics
+		.map((metric) => metric?.unit)
+		.map((unit) => mapMetricUnitToUniversalUnit(unit) || undefined);
+}

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

@@ -131,8 +131,8 @@ function MetricDetails({
 						>
 							Open in Explorer
 						</Button>
-						{/* Show the based on the feature flag. Will remove before releasing the feature */}
-						{showInspectFeature && (
+						{/* Show the inspect button if the metric type is GAUGE */}
+						{showInspectFeature && openInspectModal && (
 							<Button
 								className="inspect-metrics-button"
 								aria-label="Inspect Metric"

frontend/src/container/MetricsExplorer/MetricDetails/types.ts

@@ -11,7 +11,7 @@ export interface MetricDetailsProps {
 	isOpen: boolean;
 	metricName: string | null;
 	isModalTimeSelection: boolean;
-	openInspectModal: (metricName: string) => void;
+	openInspectModal?: (metricName: string) => void;
 }
 
 export interface DashboardsAndAlertsPopoverProps {

frontend/src/container/NewDashboard/DashboardDescription/index.tsx

@@ -20,6 +20,7 @@ import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
 import { useGetPublicDashboardMeta } from 'hooks/dashboard/useGetPublicDashboardMeta';
 import { useUpdateDashboard } from 'hooks/dashboard/useUpdateDashboard';
 import useComponentPermission from 'hooks/useComponentPermission';
+import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { useNotifications } from 'hooks/useNotifications';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import { isEmpty } from 'lodash-es';
@@ -100,6 +101,10 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 		handleDashboardLockToggle,
 	} = useDashboard();
 
+	const { isCloudUser, isEnterpriseSelfHostedUser } = useGetTenantLicense();
+
+	const isPublicDashboardEnabled = isCloudUser || isEnterpriseSelfHostedUser;
+
 	const selectedData = selectedDashboard
 		? {
 				...selectedDashboard.data,
@@ -303,12 +308,14 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 
 	const {
 		data: publicDashboardResponse,
-		// refetch: refetchPublicDashboardData,
 		isLoading: isLoadingPublicDashboardData,
 		isFetching: isFetchingPublicDashboardData,
 		error: errorPublicDashboardData,
 		isError: isErrorPublicDashboardData,
-	} = useGetPublicDashboardMeta(selectedDashboard?.id || '');
+	} = useGetPublicDashboardMeta(
+		selectedDashboard?.id || '',
+		!!selectedDashboard?.id && isPublicDashboardEnabled,
+	);
 
 	useEffect(() => {
 		if (!isLoadingPublicDashboardData && !isFetchingPublicDashboardData) {

frontend/src/container/NewDashboard/DashboardSettings/DashboardSettingsContent.styles.scss

@@ -35,6 +35,11 @@
 			display: flex;
 			align-items: center;
 			justify-content: center;
+
+			&.disabled-btn {
+				opacity: 0.5;
+				cursor: not-allowed;
+			}
 		}
 
 		.ant-tabs-ink-bar {

frontend/src/container/NewDashboard/DashboardSettings/PublicDashboard/__tests__/PublicDashboard.test.tsx

@@ -9,6 +9,7 @@ import { rest, server } from 'mocks-server/server';
 import { useDashboard } from 'providers/Dashboard/Dashboard';
 import { useCopyToClipboard } from 'react-use';
 import { render, screen, userEvent, waitFor } from 'tests/test-utils';
+import { USER_ROLES } from 'types/roles';
 
 import PublicDashboardSetting from '../index';
 
@@ -107,15 +108,11 @@ describe('PublicDashboardSetting', () => {
 				).toBeInTheDocument();
 			});
 
-			await waitFor(() => {
-				expect(
-					screen.getByRole('checkbox', { name: /enable time range/i }),
-				).toBeInTheDocument();
-			});
+			expect(
+				await screen.findByRole('checkbox', { name: /enable time range/i }),
+			).toBeInTheDocument();
 
-			await waitFor(() => {
-				expect(screen.getByText(/default time range/i)).toBeInTheDocument();
-			});
+			expect(await screen.findByText(/default time range/i)).toBeInTheDocument();
 
 			expect(screen.getByText(/Last 30 minutes/i)).toBeInTheDocument();
 
@@ -126,7 +123,7 @@ describe('PublicDashboardSetting', () => {
 			});
 
 			expect(
-				screen.getByRole('button', { name: /publish dashboard/i }),
+				await screen.findByRole('button', { name: /publish dashboard/i }),
 			).toBeInTheDocument();
 		});
 	});
@@ -151,11 +148,9 @@ describe('PublicDashboardSetting', () => {
 				).toBeInTheDocument();
 			});
 
-			await waitFor(() => {
-				expect(
-					screen.getByRole('checkbox', { name: /enable time range/i }),
-				).toBeChecked();
-			});
+			expect(
+				await screen.findByRole('checkbox', { name: /enable time range/i }),
+			).toBeChecked();
 
 			await waitFor(() => {
 				expect(screen.getByText(/default time range/i)).toBeInTheDocument();
@@ -167,17 +162,13 @@ describe('PublicDashboardSetting', () => {
 				expect(screen.getByText(/Public Dashboard URL/i)).toBeInTheDocument();
 			});
 
-			await waitFor(() => {
-				expect(
-					screen.getByRole('button', { name: /update published dashboard/i }),
-				).toBeInTheDocument();
-			});
+			expect(
+				await screen.findByRole('button', { name: /update published dashboard/i }),
+			).toBeInTheDocument();
 
-			await waitFor(() => {
-				expect(
-					screen.getByRole('button', { name: /unpublish dashboard/i }),
-				).toBeInTheDocument();
-			});
+			expect(
+				await screen.findByRole('button', { name: /unpublish dashboard/i }),
+			).toBeInTheDocument();
 		});
 	});
 
@@ -379,4 +370,64 @@ describe('PublicDashboardSetting', () => {
 			});
 		});
 	});
+
+	describe('Non-admin user permissions', () => {
+		it('should disable "Publish dashboard" button for non-admin users', async () => {
+			server.use(
+				rest.get(
+					`*/api/v1/dashboards/${MOCK_DASHBOARD_ID}/public`,
+					// eslint-disable-next-line sonarjs/no-identical-functions
+					(_req, res, ctx) =>
+						res(
+							ctx.status(StatusCodes.NOT_FOUND),
+							ctx.json(unpublishedPublicDashboardMeta),
+						),
+				),
+			);
+
+			render(<PublicDashboardSetting />, {}, { role: USER_ROLES.VIEWER });
+
+			const publishButton = await screen.findByRole('button', {
+				name: /publish dashboard/i,
+			});
+			expect(publishButton).toBeInTheDocument();
+			expect(publishButton).toBeDisabled();
+			expect(publishButton).toHaveAttribute('disabled');
+		});
+
+		describe('Published dashboard buttons for non-admin users', () => {
+			// eslint-disable-next-line sonarjs/no-identical-functions
+			beforeEach(() => {
+				server.use(
+					rest.get(
+						`*/api/v1/dashboards/${MOCK_DASHBOARD_ID}/public`,
+						(_req, res, ctx) =>
+							res(ctx.status(StatusCodes.OK), ctx.json(publishedPublicDashboardMeta)),
+					),
+				);
+			});
+
+			it('should disable "Unpublish dashboard" button for non-admin users', async () => {
+				render(<PublicDashboardSetting />, {}, { role: USER_ROLES.VIEWER });
+
+				const unpublishButton = await screen.findByRole('button', {
+					name: /unpublish dashboard/i,
+				});
+				expect(unpublishButton).toBeInTheDocument();
+				expect(unpublishButton).toBeDisabled();
+				expect(unpublishButton).toHaveAttribute('disabled');
+			});
+
+			it('should disable "Update published dashboard" button for non-admin users', async () => {
+				render(<PublicDashboardSetting />, {}, { role: USER_ROLES.VIEWER });
+
+				const updateButton = await screen.findByRole('button', {
+					name: /update published dashboard/i,
+				});
+				expect(updateButton).toBeInTheDocument();
+				expect(updateButton).toBeDisabled();
+				expect(updateButton).toHaveAttribute('disabled');
+			});
+		});
+	});
 });

frontend/src/container/NewDashboard/DashboardSettings/PublicDashboard/index.tsx

@@ -8,12 +8,16 @@ import createPublicDashboardAPI from 'api/dashboard/public/createPublicDashboard
 import revokePublicDashboardAccessAPI from 'api/dashboard/public/revokePublicDashboardAccess';
 import updatePublicDashboardAPI from 'api/dashboard/public/updatePublicDashboard';
 import { useGetPublicDashboardMeta } from 'hooks/dashboard/useGetPublicDashboardMeta';
+import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { Copy, ExternalLink, Globe, Info, Loader2, Trash } from 'lucide-react';
+import { useAppContext } from 'providers/App/App';
 import { useDashboard } from 'providers/Dashboard/Dashboard';
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useMutation } from 'react-query';
 import { useCopyToClipboard } from 'react-use';
 import { PublicDashboardMetaProps } from 'types/api/dashboard/public/getMeta';
+import APIError from 'types/api/error';
+import { USER_ROLES } from 'types/roles';
 
 export const TIME_RANGE_PRESETS_OPTIONS = [
 	{
@@ -42,6 +46,12 @@ export const TIME_RANGE_PRESETS_OPTIONS = [
 	},
 ];
 
+const showErrorNotification = (error: APIError): void => {
+	toast.error(error.getErrorCode(), {
+		description: error.getErrorMessage(),
+	});
+};
+
 function PublicDashboardSetting(): JSX.Element {
 	const [publicDashboardData, setPublicDashboardData] = useState<
 		PublicDashboardMetaProps | undefined
@@ -52,6 +62,14 @@ function PublicDashboardSetting(): JSX.Element {
 
 	const { selectedDashboard } = useDashboard();
 
+	const { isCloudUser, isEnterpriseSelfHostedUser } = useGetTenantLicense();
+
+	const isPublicDashboardEnabled = isCloudUser || isEnterpriseSelfHostedUser;
+
+	const { user } = useAppContext();
+
+	const isAdmin = user?.role === USER_ROLES.ADMIN;
+
 	const handleDefaultTimeRange = useCallback((value: string): void => {
 		setDefaultTimeRange(value);
 	}, []);
@@ -66,9 +84,12 @@ function PublicDashboardSetting(): JSX.Element {
 		isFetching: isFetchingPublicDashboard,
 		refetch: refetchPublicDashboard,
 		error: errorPublicDashboard,
-	} = useGetPublicDashboardMeta(selectedDashboard?.id || '');
+	} = useGetPublicDashboardMeta(
+		selectedDashboard?.id || '',
+		!!selectedDashboard?.id && isPublicDashboardEnabled,
+	);
 
-	const isPublicDashboardEnabled = !!publicDashboardData?.publicPath;
+	const isPublicDashboard = !!publicDashboardData?.publicPath;
 
 	useEffect(() => {
 		if (publicDashboardResponse?.data) {
@@ -102,8 +123,8 @@ function PublicDashboardSetting(): JSX.Element {
 		onSuccess: () => {
 			toast.success('Public dashboard created successfully');
 		},
-		onError: () => {
-			toast.error('Failed to create public dashboard');
+		onError: (error: APIError) => {
+			showErrorNotification(error);
 		},
 	});
 
@@ -115,8 +136,8 @@ function PublicDashboardSetting(): JSX.Element {
 		onSuccess: () => {
 			toast.success('Public dashboard updated successfully');
 		},
-		onError: () => {
-			toast.error('Failed to update public dashboard');
+		onError: (error: APIError) => {
+			showErrorNotification(error);
 		},
 	});
 
@@ -128,8 +149,8 @@ function PublicDashboardSetting(): JSX.Element {
 		onSuccess: () => {
 			toast.success('Dashboard unpublished successfully');
 		},
-		onError: () => {
-			toast.error('Failed to unpublish dashboard');
+		onError: (error: APIError) => {
+			showErrorNotification(error);
 		},
 	});
 
@@ -210,7 +231,7 @@ function PublicDashboardSetting(): JSX.Element {
 					level={5}
 					className="public-dashboard-setting-content-title"
 				>
-					{isPublicDashboardEnabled
+					{isPublicDashboard
 						? 'This dashboard is publicly accessible. Anyone with the link can view it.'
 						: 'This dashboard is private. Publish it to make it accessible to anyone with the link.'}
 				</Typography.Title>
@@ -240,7 +261,7 @@ function PublicDashboardSetting(): JSX.Element {
 					/>
 				</div>
 
-				{isPublicDashboardEnabled && (
+				{isPublicDashboard && (
 					<div className="public-dashboard-url">
 						<div className="url-label-container">
 							<Typography.Text className="url-label">
@@ -281,11 +302,11 @@ function PublicDashboardSetting(): JSX.Element {
 				</div>
 
 				<div className="public-dashboard-setting-actions">
-					{!isPublicDashboardEnabled ? (
+					{!isPublicDashboard ? (
 						<Button
 							type="primary"
 							className="create-public-dashboard-btn periscope-btn primary"
-							disabled={isLoading}
+							disabled={isLoading || !isAdmin}
 							onClick={handleCreatePublicDashboard}
 							loading={
 								isLoadingCreatePublicDashboard ||
@@ -309,7 +330,7 @@ function PublicDashboardSetting(): JSX.Element {
 							<Button
 								type="default"
 								className="periscope-btn secondary"
-								disabled={isLoading}
+								disabled={isLoading || !isAdmin}
 								onClick={handleRevokePublicDashboardAccess}
 								loading={isLoadingRevokePublicDashboardAccess}
 								icon={<Trash size={14} />}
@@ -320,7 +341,7 @@ function PublicDashboardSetting(): JSX.Element {
 							<Button
 								type="primary"
 								className="create-public-dashboard-btn periscope-btn primary"
-								disabled={isLoading}
+								disabled={isLoading || !isAdmin}
 								onClick={handleUpdatePublicDashboard}
 								loading={isLoadingUpdatePublicDashboard}
 								icon={<Globe size={14} />}

frontend/src/container/NewDashboard/DashboardSettings/Variables/VariableItem/DynamicVariable/__test__/DynamicVariable.test.tsx

@@ -1,4 +1,3 @@
-/* eslint-disable react/jsx-props-no-spreading */
 /* eslint-disable sonarjs/no-duplicate-string */
 import { fireEvent, render, screen, waitFor } from '@testing-library/react';
 import { useGetFieldKeys } from 'hooks/dynamicVariables/useGetFieldKeys';

frontend/src/container/NewDashboard/DashboardSettings/index.tsx

@@ -1,7 +1,10 @@
 import './DashboardSettingsContent.styles.scss';
 
-import { Button, Tabs } from 'antd';
+import { Button, Tabs, Tooltip } from 'antd';
+import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { Braces, Globe, Table } from 'lucide-react';
+import { useAppContext } from 'providers/App/App';
+import { USER_ROLES } from 'types/roles';
 
 import GeneralDashboardSettings from './General';
 import PublicDashboardSetting from './PublicDashboard';
@@ -12,6 +15,37 @@ function DashboardSettingsContent({
 }: {
 	variableViewModeRef: React.MutableRefObject<(() => void) | undefined>;
 }): JSX.Element {
+	const { user } = useAppContext();
+	const { isCloudUser, isEnterpriseSelfHostedUser } = useGetTenantLicense();
+
+	const enablePublicDashboard = isCloudUser || isEnterpriseSelfHostedUser;
+
+	const publicDashboardItem = {
+		label: (
+			<Tooltip
+				title={
+					user?.role !== USER_ROLES.ADMIN
+						? 'Only admins can publish / manage public dashboards'
+						: ''
+				}
+				placement="right"
+			>
+				<Button
+					type="text"
+					icon={<Globe size={14} />}
+					className={`public-dashboard-btn ${
+						user?.role !== USER_ROLES.ADMIN ? 'disabled-btn' : ''
+					}`}
+				>
+					Publish
+				</Button>
+			</Tooltip>
+		),
+		key: 'public-dashboard',
+		children: <PublicDashboardSetting />,
+		disabled: user?.role !== USER_ROLES.ADMIN,
+	};
+
 	const items = [
 		{
 			label: (
@@ -31,19 +65,7 @@ function DashboardSettingsContent({
 			key: 'variables',
 			children: <VariablesSetting variableViewModeRef={variableViewModeRef} />,
 		},
-		{
-			label: (
-				<Button
-					type="text"
-					icon={<Globe size={14} />}
-					className="public-dashboard-btn"
-				>
-					Publish
-				</Button>
-			),
-			key: 'public-dashboard',
-			children: <PublicDashboardSetting />,
-		},
+		...(enablePublicDashboard ? [publicDashboardItem] : []),
 	];
 
 	return <Tabs items={items} animated className="settings-tabs" />;

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

@@ -0,0 +1,290 @@
+/* eslint-disable react/jsx-props-no-spreading */
+import { render as rtlRender, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import { AppContext } from 'providers/App/App';
+import { IAppContext } from 'providers/App/types';
+import { DashboardProvider } from 'providers/Dashboard/Dashboard';
+import { ErrorModalProvider } from 'providers/ErrorModalProvider';
+import { QueryBuilderProvider } from 'providers/QueryBuilder';
+import React from 'react';
+import { QueryClient, QueryClientProvider } from 'react-query';
+import { Provider } from 'react-redux';
+import { MemoryRouter } from 'react-router-dom';
+import configureStore from 'redux-mock-store';
+import thunk from 'redux-thunk';
+import { LegendPosition, Widgets } from 'types/api/dashboard/getAll';
+import { EQueryType } from 'types/common/dashboard';
+import { ROLES } from 'types/roles';
+
+import RightContainer, { RightContainerProps } from '../index';
+import { timeItems, timePreferance, timePreferenceType } from '../timeItems';
+
+const mockStore = configureStore([thunk]);
+const createMockStore = (): ReturnType<typeof mockStore> =>
+	mockStore({
+		app: {
+			role: 'ADMIN',
+			user: {
+				userId: 'test-user-id',
+				email: 'test@signoz.io',
+				name: 'TestUser',
+			},
+			isLoggedIn: true,
+			org: [],
+		},
+		globalTime: {
+			minTime: '2023-01-01T00:00:00Z',
+			maxTime: '2023-01-02T00:00:00Z',
+		},
+	});
+
+const queryClient = new QueryClient({
+	defaultOptions: {
+		queries: {
+			refetchOnWindowFocus: false,
+			retry: false,
+		},
+	},
+});
+
+const createMockAppContext = (): Partial<IAppContext> => ({
+	user: {
+		accessJwt: '',
+		refreshJwt: '',
+		id: '',
+		email: '',
+		displayName: '',
+		createdAt: 0,
+		organization: '',
+		orgId: '',
+		role: 'ADMIN' as ROLES,
+	},
+});
+
+const mockWidget: Widgets = {
+	id: 'test-widget-id',
+	title: 'Test Widget',
+	description: 'Test Description',
+	panelTypes: PANEL_TYPES.TIME_SERIES,
+	query: {
+		builder: {
+			queryData: [],
+			queryFormulas: [],
+			queryTraceOperator: [],
+		},
+		promql: [],
+		clickhouse_sql: [],
+		id: 'query-id',
+		queryType: 'builder' as EQueryType,
+	},
+	timePreferance: 'GLOBAL_TIME' as timePreferenceType,
+	opacity: '',
+	nullZeroValues: '',
+	yAxisUnit: '',
+	fillSpans: false,
+	softMin: null,
+	softMax: null,
+	selectedLogFields: [],
+	selectedTracesFields: [],
+};
+
+const render = (ui: React.ReactElement): ReturnType<typeof rtlRender> =>
+	rtlRender(
+		<MemoryRouter>
+			<QueryClientProvider client={queryClient}>
+				<Provider store={createMockStore()}>
+					<AppContext.Provider value={createMockAppContext() as IAppContext}>
+						<ErrorModalProvider>
+							<DashboardProvider>
+								<QueryBuilderProvider>{ui}</QueryBuilderProvider>
+							</DashboardProvider>
+						</ErrorModalProvider>
+					</AppContext.Provider>
+				</Provider>
+			</QueryClientProvider>
+		</MemoryRouter>,
+	);
+
+// eslint-disable-next-line sonarjs/no-duplicate-string
+jest.mock('hooks/queryBuilder/useCreateAlerts', () => ({
+	__esModule: true,
+	default: jest.fn(() => jest.fn()),
+}));
+
+jest.mock('lucide-react', () => ({
+	...jest.requireActual('lucide-react'),
+	ConciergeBell: (): JSX.Element => <svg data-testid="lucide-concierge-bell" />,
+	SquareArrowOutUpRight: (): JSX.Element => (
+		<svg data-testid="lucide-square-arrow-out-up-right" />
+	),
+	Plus: (): JSX.Element => <svg data-testid="lucide-plus" />,
+}));
+
+describe('RightContainer - Alerts Section', () => {
+	const defaultProps: RightContainerProps = {
+		title: 'Test Widget',
+		setTitle: jest.fn(),
+		description: 'Test Description',
+		setDescription: jest.fn(),
+		opacity: '1',
+		setOpacity: jest.fn(),
+		selectedNullZeroValue: '',
+		setSelectedNullZeroValue: jest.fn(),
+		selectedGraph: PANEL_TYPES.TIME_SERIES,
+		setSelectedTime: jest.fn(),
+		selectedTime: timeItems[0] as timePreferance,
+		yAxisUnit: '',
+		stackedBarChart: false,
+		setStackedBarChart: jest.fn(),
+		bucketWidth: 0,
+		bucketCount: 0,
+		combineHistogram: false,
+		setCombineHistogram: jest.fn(),
+		setBucketWidth: jest.fn(),
+		setBucketCount: jest.fn(),
+		setYAxisUnit: jest.fn(),
+		decimalPrecision: 2 as const,
+		setDecimalPrecision: jest.fn(),
+		setGraphHandler: jest.fn(),
+		thresholds: [],
+		setThresholds: jest.fn(),
+		selectedWidget: mockWidget,
+		isFillSpans: false,
+		setIsFillSpans: jest.fn(),
+		softMin: null,
+		softMax: null,
+		columnUnits: {},
+		setColumnUnits: jest.fn(),
+		setSoftMin: jest.fn(),
+		setSoftMax: jest.fn(),
+		isLogScale: false,
+		setIsLogScale: jest.fn(),
+		legendPosition: LegendPosition.BOTTOM,
+		setLegendPosition: jest.fn(),
+		customLegendColors: {},
+		setCustomLegendColors: jest.fn(),
+		queryResponse: undefined,
+		contextLinks: { linksData: [] },
+		setContextLinks: jest.fn(),
+		enableDrillDown: false,
+	};
+
+	beforeEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('renders alerts section for TIME_SERIES panel type', () => {
+		render(<RightContainer {...defaultProps} />);
+
+		const alertsSection = screen.getByText('Alerts').closest('section');
+		expect(alertsSection).toBeInTheDocument();
+		expect(alertsSection).toHaveClass('alerts');
+	});
+
+	it('renders alerts section with correct text and SquareArrowOutUpRight icon', () => {
+		render(<RightContainer {...defaultProps} />);
+
+		expect(
+			screen.getByTestId('lucide-square-arrow-out-up-right'),
+		).toBeInTheDocument();
+		expect(screen.getByText('Alerts')).toBeInTheDocument();
+	});
+
+	it('calls onCreateAlertsHandler when alerts section is clicked', async () => {
+		const mockCreateAlertsHandler = jest.fn();
+		const useCreateAlerts = jest.requireMock('hooks/queryBuilder/useCreateAlerts')
+			.default;
+		useCreateAlerts.mockReturnValue(mockCreateAlertsHandler);
+
+		render(<RightContainer {...defaultProps} />);
+
+		const alertsSection = screen.getByText('Alerts').closest('section');
+		expect(alertsSection).toBeInTheDocument();
+
+		await userEvent.click(alertsSection as HTMLElement);
+
+		expect(mockCreateAlertsHandler).toHaveBeenCalledTimes(1);
+	});
+
+	it('passes correct parameters to useCreateAlerts hook', () => {
+		const useCreateAlerts = jest.requireMock('hooks/queryBuilder/useCreateAlerts')
+			.default;
+
+		render(<RightContainer {...defaultProps} />);
+
+		expect(useCreateAlerts).toHaveBeenCalledWith(mockWidget, 'panelView');
+	});
+
+	it('renders alerts section for VALUE panel type', () => {
+		render(
+			<RightContainer
+				{...defaultProps}
+				selectedGraph={PANEL_TYPES.VALUE}
+				selectedWidget={{ ...mockWidget, panelTypes: PANEL_TYPES.VALUE }}
+			/>,
+		);
+
+		expect(screen.getByText('Alerts')).toBeInTheDocument();
+	});
+
+	it('renders alerts section for BAR panel type', () => {
+		render(
+			<RightContainer
+				{...defaultProps}
+				selectedGraph={PANEL_TYPES.BAR}
+				selectedWidget={{ ...mockWidget, panelTypes: PANEL_TYPES.BAR }}
+			/>,
+		);
+
+		expect(screen.getByText('Alerts')).toBeInTheDocument();
+	});
+
+	it('does not render alerts section for TABLE panel type', () => {
+		render(
+			<RightContainer
+				{...defaultProps}
+				selectedGraph={PANEL_TYPES.TABLE}
+				selectedWidget={{ ...mockWidget, panelTypes: PANEL_TYPES.TABLE }}
+			/>,
+		);
+
+		expect(screen.queryByText('Alerts')).not.toBeInTheDocument();
+	});
+
+	it('does not render alerts section for LIST panel type', () => {
+		render(
+			<RightContainer
+				{...defaultProps}
+				selectedGraph={PANEL_TYPES.LIST}
+				selectedWidget={{ ...mockWidget, panelTypes: PANEL_TYPES.LIST }}
+			/>,
+		);
+
+		expect(screen.queryByText('Alerts')).not.toBeInTheDocument();
+	});
+
+	it('does not render alerts section for PIE panel type', () => {
+		render(
+			<RightContainer
+				{...defaultProps}
+				selectedGraph={PANEL_TYPES.PIE}
+				selectedWidget={{ ...mockWidget, panelTypes: PANEL_TYPES.PIE }}
+			/>,
+		);
+
+		expect(screen.queryByText('Alerts')).not.toBeInTheDocument();
+	});
+
+	it('does not render alerts section for HISTOGRAM panel type', () => {
+		render(
+			<RightContainer
+				{...defaultProps}
+				selectedGraph={PANEL_TYPES.HISTOGRAM}
+				selectedWidget={{ ...mockWidget, panelTypes: PANEL_TYPES.HISTOGRAM }}
+			/>,
+		);
+
+		expect(screen.queryByText('Alerts')).not.toBeInTheDocument();
+	});
+});

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

@@ -20,7 +20,13 @@ import GraphTypes, {
 } from 'container/NewDashboard/ComponentsSlider/menuItems';
 import useCreateAlerts from 'hooks/queryBuilder/useCreateAlerts';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { ConciergeBell, LineChart, Plus, Spline } from 'lucide-react';
+import {
+	ConciergeBell,
+	LineChart,
+	Plus,
+	Spline,
+	SquareArrowOutUpRight,
+} from 'lucide-react';
 import { useDashboard } from 'providers/Dashboard/Dashboard';
 import {
 	Dispatch,
@@ -140,11 +146,7 @@ function RightContainer({
 	const selectedGraphType =
 		GraphTypes.find((e) => e.name === selectedGraph)?.display || '';
 
-	const onCreateAlertsHandler = useCreateAlerts(
-		selectedWidget,
-		'panelView',
-		thresholds,
-	);
+	const onCreateAlertsHandler = useCreateAlerts(selectedWidget, 'panelView');
 
 	const allowThreshold = panelTypeVsThreshold[selectedGraph];
 	const allowSoftMinMax = panelTypeVsSoftMinMax[selectedGraph];
@@ -530,6 +532,7 @@ function RightContainer({
 					<div className="left-section">
 						<ConciergeBell size={14} className="bell-icon" />
 						<Typography.Text className="alerts-text">Alerts</Typography.Text>
+						<SquareArrowOutUpRight size={10} className="info-icon" />
 					</div>
 					<Plus size={14} className="plus-icon" />
 				</section>
@@ -560,7 +563,7 @@ function RightContainer({
 	);
 }
 
-interface RightContainerProps {
+export interface RightContainerProps {
 	title: string;
 	setTitle: Dispatch<SetStateAction<string>>;
 	description: string;

frontend/src/container/NewWidget/index.tsx

@@ -370,10 +370,6 @@ function NewWidget({
 	// this has been moved here from the left container
 	const [requestData, setRequestData] = useState<GetQueryResultsProps>(() => {
 		const updatedQuery = cloneDeep(stagedQuery || initialQueriesMap.metrics);
-		if (updatedQuery?.builder?.queryData?.[0]) {
-			updatedQuery.builder.queryData[0].pageSize = 10;
-		}
-
 		if (selectedWidget) {
 			if (selectedGraph === PANEL_TYPES.LIST) {
 				return {
@@ -419,16 +415,12 @@ function NewWidget({
 	useEffect(() => {
 		if (stagedQuery) {
 			setIsLoadingPanelData(false);
-			const updatedStagedQuery = cloneDeep(stagedQuery);
-			if (updatedStagedQuery?.builder?.queryData?.[0]) {
-				updatedStagedQuery.builder.queryData[0].pageSize = 10;
-			}
 			setRequestData((prev) => ({
 				...prev,
 				selectedTime: selectedTime.enum || prev.selectedTime,
 				globalSelectedInterval: customGlobalSelectedInterval,
 				graphType: getGraphType(selectedGraph || selectedWidget.panelTypes),
-				query: updatedStagedQuery,
+				query: stagedQuery,
 				fillGaps: selectedWidget.fillSpans || false,
 				isLogScale: selectedWidget.isLogScale || false,
 				formatForWeb:

frontend/src/container/OnboardingV2Container/AddDataSource/AddDataSource.tsx

@@ -14,6 +14,7 @@ import {
 } from 'antd';
 import logEvent from 'api/common/logEvent';
 import LaunchChatSupport from 'components/LaunchChatSupport/LaunchChatSupport';
+import { DOCS_BASE_URL } from 'constants/app';
 import ROUTES from 'constants/routes';
 import useDebouncedFn from 'hooks/useDebouncedFunction';
 import history from 'lib/history';
@@ -50,6 +51,15 @@ interface Option {
 	label: string;
 	link?: string;
 	entityID?: string;
+	internalRedirect?: boolean;
+	question?: {
+		desc: string;
+		options: Option[];
+		entityID?: string;
+		helpText?: string;
+		helpLink?: string;
+		helpLinkText?: string;
+	};
 }
 
 interface Entity {
@@ -62,6 +72,9 @@ interface Entity {
 		desc: string;
 		options: Option[];
 		entityID: string;
+		helpText?: string;
+		helpLink?: string;
+		helpLinkText?: string;
 		question?: {
 			desc: string;
 			options: Option[];
@@ -106,11 +119,32 @@ const ONBOARDING_V3_ANALYTICS_EVENTS_MAP = {
 	DATA_SOURCE_SEARCHED: 'Searched',
 };
 
+const groupDataSourcesByTags = (
+	dataSources: Entity[],
+): { [tag: string]: Entity[] } => {
+	const groupedDataSources: { [tag: string]: Entity[] } = {};
+
+	dataSources.forEach((dataSource) => {
+		dataSource.tags.forEach((tag) => {
+			if (!groupedDataSources[tag]) {
+				groupedDataSources[tag] = [];
+			}
+			groupedDataSources[tag].push(dataSource);
+		});
+	});
+
+	return groupedDataSources;
+};
+
+const allGroupedDataSources = groupDataSourcesByTags(
+	onboardingConfigWithLinks as Entity[],
+);
+
 // eslint-disable-next-line sonarjs/cognitive-complexity
 function OnboardingAddDataSource(): JSX.Element {
 	const [groupedDataSources, setGroupedDataSources] = useState<{
 		[tag: string]: Entity[];
-	}>({});
+	}>(allGroupedDataSources);
 
 	const { org } = useAppContext();
 
@@ -143,7 +177,7 @@ function OnboardingAddDataSource(): JSX.Element {
 	] = useState<boolean>(false);
 
 	const [docsUrl, setDocsUrl] = useState<string>(
-		'https://signoz.io/docs/instrumentation/',
+		`${DOCS_BASE_URL}/docs/instrumentation/`,
 	);
 
 	const [selectedDataSource, setSelectedDataSource] = useState<Entity | null>(
@@ -188,7 +222,9 @@ function OnboardingAddDataSource(): JSX.Element {
 		}
 
 		// Step 1: Parse the URL
-		const urlObj = new URL(url);
+		const fullUrl = url.startsWith('/') ? `${DOCS_BASE_URL}${url}` : url;
+
+		const urlObj = new URL(fullUrl);
 
 		// Step 2: Update or add the 'source' parameter
 		urlObj.searchParams.set('source', 'onboarding');
@@ -204,45 +240,33 @@ function OnboardingAddDataSource(): JSX.Element {
 	};
 
 	const handleSelectDataSource = (dataSource: Entity): void => {
-		if (dataSource && dataSource.internalRedirect && dataSource.link) {
-			logEvent(
-				`${ONBOARDING_V3_ANALYTICS_EVENTS_MAP?.BASE}: ${ONBOARDING_V3_ANALYTICS_EVENTS_MAP?.DATA_SOURCE_SELECTED}`,
-				{
-					dataSource: dataSource.label,
-				},
-			);
-			history.push(dataSource.link);
+		setSelectedDataSource(dataSource);
+		setSelectedFramework(null);
+		setSelectedEnvironment(null);
+
+		logEvent(
+			`${ONBOARDING_V3_ANALYTICS_EVENTS_MAP?.BASE}: ${ONBOARDING_V3_ANALYTICS_EVENTS_MAP?.DATA_SOURCE_SELECTED}`,
+			{
+				dataSource: dataSource.label,
+			},
+		);
+
+		if (dataSource.question) {
+			setHasMoreQuestions(true);
+
+			setTimeout(() => {
+				handleScrollToStep(question2Ref);
+			}, 100);
 		} else {
-			setSelectedDataSource(dataSource);
-			setSelectedFramework(null);
-			setSelectedEnvironment(null);
+			setHasMoreQuestions(false);
 
-			logEvent(
-				`${ONBOARDING_V3_ANALYTICS_EVENTS_MAP?.BASE}: ${ONBOARDING_V3_ANALYTICS_EVENTS_MAP?.DATA_SOURCE_SELECTED}`,
-				{
-					dataSource: dataSource.label,
-				},
-			);
+			updateUrl(dataSource?.link || '', null);
 
-			if (dataSource.question) {
-				setHasMoreQuestions(true);
-
-				setTimeout(() => {
-					handleScrollToStep(question2Ref);
-				}, 100);
-			} else {
-				setHasMoreQuestions(false);
-
-				updateUrl(dataSource?.link || '', null);
-
-				setShowConfigureProduct(true);
-			}
+			setShowConfigureProduct(true);
 		}
 	};
 
 	const handleSelectFramework = (option: any): void => {
-		setSelectedFramework(option);
-
 		logEvent(
 			`${ONBOARDING_V3_ANALYTICS_EVENTS_MAP?.BASE}: ${ONBOARDING_V3_ANALYTICS_EVENTS_MAP?.FRAMEWORK_SELECTED}`,
 			{
@@ -251,6 +275,8 @@ function OnboardingAddDataSource(): JSX.Element {
 			},
 		);
 
+		setSelectedFramework(option);
+
 		if (option.question) {
 			setHasMoreQuestions(true);
 
@@ -274,9 +300,6 @@ function OnboardingAddDataSource(): JSX.Element {
 		selectedEnvironment: any,
 		baseURL?: string,
 	): void => {
-		setSelectedEnvironment(selectedEnvironment);
-		setHasMoreQuestions(false);
-
 		logEvent(
 			`${ONBOARDING_V3_ANALYTICS_EVENTS_MAP?.BASE}: ${ONBOARDING_V3_ANALYTICS_EVENTS_MAP?.ENVIRONMENT_SELECTED}`,
 			{
@@ -286,45 +309,21 @@ function OnboardingAddDataSource(): JSX.Element {
 			},
 		);
 
+		setSelectedEnvironment(selectedEnvironment);
+		setHasMoreQuestions(false);
+
 		updateUrl(baseURL || docsUrl, selectedEnvironment?.key);
 
 		setShowConfigureProduct(true);
 	};
 
-	const groupDataSourcesByTags = (
-		dataSources: Entity[],
-	): { [tag: string]: Entity[] } => {
-		const groupedDataSources: { [tag: string]: Entity[] } = {};
-
-		dataSources.forEach((dataSource) => {
-			dataSource.tags.forEach((tag) => {
-				if (!groupedDataSources[tag]) {
-					groupedDataSources[tag] = [];
-				}
-				groupedDataSources[tag].push(dataSource);
-			});
-		});
-
-		return groupedDataSources;
-	};
-
-	useEffect(() => {
-		const groupedDataSources = groupDataSourcesByTags(
-			onboardingConfigWithLinks as Entity[],
-		);
-
-		setGroupedDataSources(groupedDataSources);
-	}, []);
-
 	const debouncedUpdate = useDebouncedFn((query) => {
 		setSearchQuery(query as string);
 
 		setDataSourceRequestSubmitted(false);
 
 		if (query === '') {
-			setGroupedDataSources(
-				groupDataSourcesByTags(onboardingConfigWithLinks as Entity[]),
-			);
+			setGroupedDataSources(allGroupedDataSources);
 			return;
 		}
 
@@ -360,31 +359,35 @@ function OnboardingAddDataSource(): JSX.Element {
 		},
 		[debouncedUpdate],
 	);
+
 	const handleFilterByCategory = (category: string): void => {
 		setSelectedDataSource(null);
 		setSelectedFramework(null);
 		setSelectedEnvironment(null);
 
-		if (category === 'All') {
-			setGroupedDataSources(
-				groupDataSourcesByTags(onboardingConfigWithLinks as Entity[]),
-			);
+		setSelectedCategory(category);
 
-			setSelectedCategory('All');
+		if (category === 'All') {
+			setGroupedDataSources(allGroupedDataSources);
 			return;
 		}
 
-		const filteredDataSources = onboardingConfigWithLinks.filter(
-			(dataSource) =>
-				dataSource.tags.includes(category) ||
-				dataSource.tags.some((tag) => tag.toLowerCase().includes(category)),
-		);
-
-		setSelectedCategory(category);
-
-		setGroupedDataSources(
-			groupDataSourcesByTags(filteredDataSources as Entity[]),
-		);
+		if (allGroupedDataSources[category]) {
+			setGroupedDataSources({
+				[category]: allGroupedDataSources[category],
+			});
+		} else {
+			// Fallback if somehow the category key doesn't strictly match or relies on partial match
+			// This preserves the old behavior as a fallback, though sidebar clicks should be exact matches
+			const filteredDataSources = onboardingConfigWithLinks.filter(
+				(dataSource) =>
+					dataSource.tags.includes(category) ||
+					dataSource.tags.some((tag) => tag.toLowerCase().includes(category)),
+			);
+			setGroupedDataSources(
+				groupDataSourcesByTags(filteredDataSources as Entity[]),
+			);
+		}
 	};
 
 	useEffect(() => {
@@ -778,7 +781,7 @@ function OnboardingAddDataSource(): JSX.Element {
 														</Typography.Text>
 													</div>
 
-													{Object.keys(groupedDataSources).map((tag) => (
+													{Object.keys(allGroupedDataSources).map((tag) => (
 														<div
 															key={tag}
 															className="onboarding-data-source-category-item"
@@ -803,7 +806,7 @@ function OnboardingAddDataSource(): JSX.Element {
 															<div className="line-divider" />
 
 															<Typography.Text className="onboarding-filters-item-count">
-																{groupedDataSources[tag].length}
+																{allGroupedDataSources[tag].length}
 															</Typography.Text>
 														</div>
 													))}
@@ -828,6 +831,22 @@ function OnboardingAddDataSource(): JSX.Element {
 																>
 																	{selectedDataSource?.question?.desc}
 																</Typography.Title>
+																{selectedDataSource?.question?.helpText && (
+																	<Typography.Text className="question-help-text">
+																		{selectedDataSource?.question?.helpText}
+																		{selectedDataSource?.question?.helpLink && (
+																			<a
+																				href={`${DOCS_BASE_URL}${selectedDataSource?.question?.helpLink}`}
+																				target="_blank"
+																				rel="noopener noreferrer"
+																				className="question-help-link"
+																			>
+																				{selectedDataSource?.question?.helpLinkText ||
+																					'Learn more →'}
+																			</a>
+																		)}
+																	</Typography.Text>
+																)}
 															</div>
 
 															<div className="onboarding-data-source-options">
@@ -882,6 +901,22 @@ function OnboardingAddDataSource(): JSX.Element {
 																>
 																	{selectedFramework?.question?.desc}
 																</Typography.Title>
+																{selectedFramework?.question?.helpText && (
+																	<Typography.Text className="question-help-text">
+																		{selectedFramework?.question?.helpText}
+																		{selectedFramework?.question?.helpLink && (
+																			<a
+																				href={`${DOCS_BASE_URL}${selectedFramework?.question?.helpLink}`}
+																				target="_blank"
+																				rel="noopener noreferrer"
+																				className="question-help-link"
+																			>
+																				{selectedFramework?.question?.helpLinkText ||
+																					'Learn more →'}
+																			</a>
+																		)}
+																	</Typography.Text>
+																)}
 															</div>
 
 															<div className="onboarding-data-source-options">
@@ -892,7 +927,9 @@ function OnboardingAddDataSource(): JSX.Element {
 																			selectedEnvironment?.label === option.label ? 'selected' : ''
 																		}`}
 																		type="primary"
-																		onClick={(): void => handleSelectEnvironment(option)}
+																		onClick={(): void =>
+																			handleSelectEnvironment(option, option.link)
+																		}
 																	>
 																		<img
 																			src={option.imgUrl || '/Logos/signoz-brand-logo-new.svg'}
@@ -923,7 +960,14 @@ function OnboardingAddDataSource(): JSX.Element {
 															},
 														);
 
-														handleUpdateCurrentStep(2);
+														const currentEntity =
+															selectedEnvironment || selectedFramework || selectedDataSource;
+
+														if (currentEntity?.internalRedirect && currentEntity?.link) {
+															history.push(currentEntity.link);
+														} else {
+															handleUpdateCurrentStep(2);
+														}
 													}}
 												>
 													Next: Configure your product

frontend/src/container/OnboardingV2Container/IngestionDetails/IngestionDetails.styles.scss

@@ -0,0 +1,33 @@
+.ingestion-url-error-tooltip {
+	.ingestion-url-error-content {
+		display: flex;
+		flex-direction: column;
+		gap: 8px;
+	}
+
+	.ingestion-url-error-code {
+		font-size: 12px;
+		font-weight: 500;
+		color: var(--bg-amber-500);
+	}
+
+	.ingestion-url-error-message {
+		font-size: 12px;
+		font-weight: 400;
+		color: var(--bg-vanilla-300);
+	}
+}
+
+.lightMode {
+	.ingestion-url-error-tooltip {
+		.ingestion-url-error-content {
+			.ingestion-url-error-code {
+				color: var(--bg-amber-500);
+			}
+		}
+
+		.ingestion-url-error-message {
+			color: var(--bg-ink-500);
+		}
+	}
+}

frontend/src/container/OnboardingV2Container/IngestionDetails/IngestionDetails.tsx

@@ -1,17 +1,13 @@
-import { Skeleton, Typography } from 'antd';
+import './IngestionDetails.styles.scss';
+
+import { Button, Skeleton, Tooltip, Typography } from 'antd';
 import logEvent from 'api/common/logEvent';
 import { AxiosError } from 'axios';
-import { useGetDeploymentsData } from 'hooks/CustomDomain/useGetDeploymentsData';
+import { DOCS_BASE_URL } from 'constants/app';
+import { useGetGlobalConfig } from 'hooks/globalConfig/useGetGlobalConfig';
 import { useGetAllIngestionsKeys } from 'hooks/IngestionKeys/useGetAllIngestionKeys';
 import { useNotifications } from 'hooks/useNotifications';
-import {
-	ArrowUpRight,
-	Copy,
-	Info,
-	Key,
-	MapPin,
-	TriangleAlert,
-} from 'lucide-react';
+import { ArrowUpRight, Copy, Info, Key, TriangleAlert } from 'lucide-react';
 import { useEffect, useState } from 'react';
 import { useCopyToClipboard } from 'react-use';
 import { IngestionKeyProps } from 'types/api/ingestionKeys/types';
@@ -59,11 +55,11 @@ export default function OnboardingIngestionDetails(): JSX.Element {
 	});
 
 	const {
-		data: deploymentsData,
-		isLoading: isLoadingDeploymentsData,
-		isFetching: isFetchingDeploymentsData,
-		isError: isDeploymentsDataError,
-	} = useGetDeploymentsData(true);
+		data: globalConfig,
+		isLoading: isLoadingGlobalConfig,
+		isError: isErrorGlobalConfig,
+		error: globalConfigError,
+	} = useGetGlobalConfig();
 
 	const handleCopyKey = (text: string): void => {
 		handleCopyToClipboard(text);
@@ -93,7 +89,7 @@ export default function OnboardingIngestionDetails(): JSX.Element {
 						<span>
 							Find your ingestion URL and learn more about sending data to SigNoz{' '}
 							<a
-								href="https://signoz.io/docs/ingestion/signoz-cloud/overview/"
+								href={`${DOCS_BASE_URL}/docs/ingestion/signoz-cloud/overview/`}
 								target="_blank"
 								className="learn-more"
 								rel="noreferrer"
@@ -113,9 +109,7 @@ export default function OnboardingIngestionDetails(): JSX.Element {
 						</Typography.Text>
 
 						<div className="ingestion-key-details-section-key">
-							{isIngestionKeysLoading ||
-							isLoadingDeploymentsData ||
-							isFetchingDeploymentsData ? (
+							{isIngestionKeysLoading || isLoadingGlobalConfig ? (
 								<div className="skeleton-container">
 									<Skeleton.Input active className="skeleton-input" />
 									<Skeleton.Input active className="skeleton-input" />
@@ -124,34 +118,58 @@ export default function OnboardingIngestionDetails(): JSX.Element {
 								</div>
 							) : (
 								<div className="ingestion-key-region-details-section">
-									{!isDeploymentsDataError &&
-										!isLoadingDeploymentsData &&
-										!isFetchingDeploymentsData && (
-											<div className="ingestion-region-container">
-												<Typography.Text className="ingestion-region-label">
-													<MapPin size={14} /> Region
-												</Typography.Text>
+									{!isLoadingGlobalConfig && (
+										<div className="ingestion-region-container">
+											<Typography.Text className="ingestion-region-label">
+												Ingestion URL
+											</Typography.Text>
 
+											{!isErrorGlobalConfig && (
 												<Typography.Text className="ingestion-region-value-copy">
-													{deploymentsData?.data?.data?.cluster.region.name}
+													{globalConfig?.data?.ingestion_url}
 
 													<Copy
 														size={14}
 														className="copy-btn"
 														onClick={(): void => {
 															logEvent(
-																`${ONBOARDING_V3_ANALYTICS_EVENTS_MAP?.BASE}: ${ONBOARDING_V3_ANALYTICS_EVENTS_MAP?.REGION_COPIED}`,
+																`${ONBOARDING_V3_ANALYTICS_EVENTS_MAP?.BASE}: ${ONBOARDING_V3_ANALYTICS_EVENTS_MAP?.INGESTION_URL_COPIED}`,
 																{},
 															);
 
-															handleCopyKey(
-																deploymentsData?.data?.data?.cluster.region.name || '',
-															);
+															const ingestionURL = globalConfig?.data?.ingestion_url;
+
+															if (ingestionURL) {
+																handleCopyKey(ingestionURL);
+															}
 														}}
 													/>
 												</Typography.Text>
-											</div>
-										)}
+											)}
+
+											{isErrorGlobalConfig && (
+												<Tooltip
+													rootClassName="ingestion-url-error-tooltip"
+													arrow={false}
+													title={
+														<div className="ingestion-url-error-content">
+															<Typography.Text className="ingestion-url-error-code">
+																{globalConfigError?.getErrorCode()}
+															</Typography.Text>
+
+															<Typography.Text className="ingestion-url-error-message">
+																{globalConfigError?.getErrorMessage()}
+															</Typography.Text>
+														</div>
+													}
+													placement="topLeft"
+												>
+													<Button type="text" icon={<TriangleAlert size={14} />} />
+												</Tooltip>
+											)}
+										</div>
+									)}
+
 									<div className="ingestion-key-container">
 										<Typography.Text className="ingestion-key-label">
 											<Key size={14} /> Ingestion Key
@@ -184,7 +202,7 @@ export default function OnboardingIngestionDetails(): JSX.Element {
 						<span>
 							We support{' '}
 							<a
-								href="https://signoz.io/docs/ingestion/signoz-cloud/keys/"
+								href={`${DOCS_BASE_URL}/docs/ingestion/signoz-cloud/keys/`}
 								target="_blank"
 								className="learn-more"
 								rel="noreferrer"

frontend/src/container/OnboardingV2Container/OnboardingV2.styles.scss

@@ -577,6 +577,38 @@
 		margin-bottom: 24px;
 	}
 
+	.question-help-text {
+		display: block;
+		margin-top: 8px;
+		color: var(--text-vanilla-400);
+		font-family: Inter;
+		font-size: 13px;
+		font-style: normal;
+		font-weight: 400;
+		line-height: 22px;
+
+		.lightMode & {
+			color: var(--text-ink-300);
+		}
+	}
+
+	.question-help-link {
+		margin-left: 4px;
+		color: var(--bg-robin-400);
+		text-decoration: none;
+		font-weight: 500;
+		transition: color 0.2s ease;
+
+		&:hover {
+			color: var(--bg-robin-500);
+			text-decoration: underline;
+		}
+
+		.lightMode & {
+			color: var(--bg-robin-500);
+		}
+	}
+
 	.onboarding-question {
 		color: var(--text-vanilla-100);
 		font-family: Inter;

frontend/src/container/OptionsMenu/__test__/useOptionsMenu.test.ts

@@ -37,7 +37,7 @@ describe('useOptionsMenu', () => {
 					columns: [],
 					formatting: {
 						format: 'raw',
-						maxLines: 2,
+						maxLines: 1,
 						fontSize: 'small',
 					},
 				},
@@ -49,7 +49,7 @@ describe('useOptionsMenu', () => {
 					columns: [],
 					formatting: {
 						format: 'raw',
-						maxLines: 2,
+						maxLines: 1,
 						fontSize: 'small',
 					},
 				},

frontend/src/container/OptionsMenu/constants.ts

@@ -7,7 +7,7 @@ export const URL_OPTIONS = 'options';
 
 export const defaultOptionsQuery: OptionsQuery = {
 	selectColumns: [],
-	maxLines: 2,
+	maxLines: 1,
 	format: 'raw',
 	fontSize: FontSize.SMALL,
 };

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

@@ -118,8 +118,7 @@ function UserFunction({
 			if (role !== accessLevel) {
 				notifications.success({
 					message: 'User details updated successfully',
-					description:
-						'The user details have been updated successfully. Please request the user to logout and login again to access the platform with updated privileges.',
+					description: 'The user details have been updated successfully.',
 				});
 			} else {
 				notifications.success({

frontend/src/container/PanelWrapper/UplotPanelWrapper.tsx

@@ -132,11 +132,20 @@ function UplotPanelWrapper({
 		[selectedGraph, widget?.panelTypes, widget?.stackedBarChart],
 	);
 
-	const chartData = getUPlotChartData(
-		queryResponse?.data?.payload,
-		widget.fillSpans,
-		stackedBarChart,
-		hiddenGraph,
+	const chartData = useMemo(
+		() =>
+			getUPlotChartData(
+				queryResponse?.data?.payload,
+				widget.fillSpans,
+				stackedBarChart,
+				hiddenGraph,
+			),
+		[
+			queryResponse?.data?.payload,
+			widget.fillSpans,
+			stackedBarChart,
+			hiddenGraph,
+		],
 	);
 
 	useEffect(() => {
@@ -293,7 +302,7 @@ function UplotPanelWrapper({
 			)}
 			{isFullViewMode && setGraphVisibility && !stackedBarChart && (
 				<GraphManager
-					data={getUPlotChartData(queryResponse?.data?.payload, widget.fillSpans)}
+					data={chartData}
 					name={widget.id}
 					options={options}
 					yAxisUnit={widget.yAxisUnit}

frontend/src/container/PipelinePage/tests/PipelineListsView.test.tsx

@@ -62,7 +62,7 @@ jest.mock('providers/preferences/sync/usePreferenceSync', () => ({
 		preferences: {
 			columns: [],
 			formatting: {
-				maxLines: 2,
+				maxLines: 1,
 				format: 'table',
 				fontSize: 'small',
 				version: 1,

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

@@ -206,6 +206,10 @@
 			.ant-select-selector {
 				border-color: var(--bg-vanilla-300);
 				background: var(--bg-vanilla-300);
+
+				.ant-select-selection-item {
+					color: var(--text-ink-400);
+				}
 			}
 
 			.ant-input-number {

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

@@ -242,6 +242,7 @@ export function Formula({
 								</div>
 								<InputWithLabel
 									label="Limit"
+									type="number"
 									onChange={(value): void => handleChangeLimit(Number(value))}
 									initialValue={formula?.limit ?? undefined}
 									placeholder="Enter limit"

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

@@ -1,7 +1,5 @@
 import { Select } from 'antd';
 import { ATTRIBUTE_TYPES, PANEL_TYPES } from 'constants/queryBuilder';
-import { useEffect, useState } from 'react';
-import { MetricAggregateOperator } from 'types/common/queryBuilder';
 
 interface SpaceAggregationOptionsProps {
 	panelType: PANEL_TYPES | null;
@@ -22,39 +20,13 @@ export default function SpaceAggregationOptions({
 	operators,
 	qbVersion,
 }: SpaceAggregationOptionsProps): JSX.Element {
-	const placeHolderText =
-		panelType === PANEL_TYPES.VALUE || qbVersion === 'v3' ? 'Sum' : 'Sum By';
-	const [defaultValue, setDefaultValue] = useState(
-		selectedValue || placeHolderText,
-	);
-
-	useEffect(() => {
-		if (!selectedValue) {
-			if (
-				aggregatorAttributeType === ATTRIBUTE_TYPES.HISTOGRAM ||
-				aggregatorAttributeType === ATTRIBUTE_TYPES.EXPONENTIAL_HISTOGRAM
-			) {
-				setDefaultValue(MetricAggregateOperator.P90);
-				onSelect(MetricAggregateOperator.P90);
-			} else if (aggregatorAttributeType === ATTRIBUTE_TYPES.SUM) {
-				setDefaultValue(MetricAggregateOperator.SUM);
-				onSelect(MetricAggregateOperator.SUM);
-			} else if (aggregatorAttributeType === ATTRIBUTE_TYPES.GAUGE) {
-				setDefaultValue(MetricAggregateOperator.AVG);
-				onSelect(MetricAggregateOperator.AVG);
-			}
-		}
-
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [aggregatorAttributeType]);
-
 	return (
 		<div
 			className="spaceAggregationOptionsContainer"
 			key={aggregatorAttributeType}
 		>
 			<Select
-				defaultValue={defaultValue}
+				defaultValue={selectedValue}
 				style={{ minWidth: '5.625rem' }}
 				disabled={disabled}
 				onChange={onSelect}

frontend/src/container/QueryBuilder/filters/QueryBuilderSearch/OptionRenderer.styles.scss

@@ -0,0 +1,16 @@
+.selectOptionContainer {
+	display: flex;
+	gap: 8px;
+	justify-content: space-between;
+	align-items: center;
+	overflow-x: auto;
+
+	&::-webkit-scrollbar {
+		width: 0.2rem;
+		height: 0.2rem;
+	}
+}
+
+.option-renderer-tooltip {
+	pointer-events: none;
+}

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

@@ -1,4 +1,4 @@
-import './QueryBuilderSearch.styles.scss';
+import './OptionRenderer.styles.scss';
 
 import { Tooltip } from 'antd';
 
@@ -13,7 +13,11 @@ function OptionRenderer({
 	return (
 		<span className="option">
 			{type ? (
-				<Tooltip title={`${value}`} placement="topLeft">
+				<Tooltip
+					title={`${value}`}
+					placement="topLeft"
+					rootClassName="option-renderer-tooltip"
+				>
 					<div className="selectOptionContainer">
 						<div className="option-value">{value}</div>
 						<div className="option-meta-data-container">
@@ -29,7 +33,11 @@ function OptionRenderer({
 					</div>
 				</Tooltip>
 			) : (
-				<Tooltip title={label} placement="topLeft">
+				<Tooltip
+					title={label}
+					placement="topLeft"
+					rootClassName="option-renderer-tooltip"
+				>
 					<span>{label}</span>
 				</Tooltip>
 			)}

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

@@ -5,19 +5,6 @@
 	gap: 12px;
 }
 
-.selectOptionContainer {
-	display: flex;
-	gap: 8px;
-	justify-content: space-between;
-	align-items: center;
-	overflow-x: auto;
-
-	&::-webkit-scrollbar {
-		width: 0.2rem;
-		height: 0.2rem;
-	}
-}
-
 .logs-popup {
 	&.hide-scroll {
 		.rc-virtual-list-holder {

frontend/src/container/QueryBuilder/filters/ReduceToFilter/ReduceToFilter.test.tsx

@@ -0,0 +1,88 @@
+import { render, screen } from '@testing-library/react';
+import { MetricType } from 'api/metricsExplorer/getMetricsList';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+
+import { ReduceToFilter } from './ReduceToFilter';
+
+const mockOnChange = jest.fn();
+
+function baseQuery(overrides: Partial<IBuilderQuery> = {}): IBuilderQuery {
+	return {
+		dataSource: 'traces',
+		aggregations: [],
+		groupBy: [],
+		orderBy: [],
+		legend: '',
+		limit: null,
+		having: { expression: '' },
+		...overrides,
+	} as IBuilderQuery;
+}
+
+describe('ReduceToFilter', () => {
+	beforeEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('initializes with default avg when no reduceTo is set', () => {
+		render(<ReduceToFilter query={baseQuery()} onChange={mockOnChange} />);
+
+		expect(screen.getByTestId('reduce-to')).toBeInTheDocument();
+		expect(
+			screen.getByText('Average of values in timeframe'),
+		).toBeInTheDocument();
+	});
+
+	it('initializes from query.aggregations[0].reduceTo', () => {
+		render(
+			<ReduceToFilter
+				query={baseQuery({
+					aggregations: [{ reduceTo: 'sum' } as any],
+					aggregateAttribute: { key: 'test', type: MetricType.SUM },
+				})}
+				onChange={mockOnChange}
+			/>,
+		);
+
+		expect(screen.getByText('Sum of values in timeframe')).toBeInTheDocument();
+	});
+
+	it('initializes from query.reduceTo when aggregations[0].reduceTo is not set', () => {
+		render(
+			<ReduceToFilter
+				query={baseQuery({
+					reduceTo: 'max',
+					aggregateAttribute: { key: 'test', type: MetricType.GAUGE },
+				})}
+				onChange={mockOnChange}
+			/>,
+		);
+
+		expect(screen.getByText('Max of values in timeframe')).toBeInTheDocument();
+	});
+
+	it('updates to sum when aggregateAttribute.type is SUM', async () => {
+		const { rerender } = render(
+			<ReduceToFilter
+				query={baseQuery({
+					aggregateAttribute: { key: 'test', type: MetricType.GAUGE },
+				})}
+				onChange={mockOnChange}
+			/>,
+		);
+
+		rerender(
+			<ReduceToFilter
+				query={baseQuery({
+					aggregateAttribute: { key: 'test2', type: MetricType.SUM },
+				})}
+				onChange={mockOnChange}
+			/>,
+		);
+
+		const reduceToFilterText = (await screen.findByText(
+			'Sum of values in timeframe',
+		)) as HTMLElement;
+		expect(reduceToFilterText).toBeInTheDocument();
+	});
+});

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

@@ -1,6 +1,7 @@
 import { Select } from 'antd';
+import { MetricType } from 'api/metricsExplorer/getMetricsList';
 import { REDUCE_TO_VALUES } from 'constants/queryBuilder';
-import { memo } from 'react';
+import { memo, useEffect, useRef, useState } from 'react';
 import { MetricAggregation } from 'types/api/v5/queryRange';
 // ** Types
 import { ReduceOperators } from 'types/common/queryBuilder';
@@ -12,19 +13,46 @@ export const ReduceToFilter = memo(function ReduceToFilter({
 	query,
 	onChange,
 }: ReduceToFilterProps): JSX.Element {
-	const reduceToValue =
-		(query.aggregations?.[0] as MetricAggregation)?.reduceTo || query.reduceTo;
-
-	const currentValue =
-		REDUCE_TO_VALUES.find((option) => option.value === reduceToValue) ||
-		REDUCE_TO_VALUES[0];
+	const isMounted = useRef<boolean>(false);
+	const [currentValue, setCurrentValue] = useState<
+		SelectOption<ReduceOperators, string>
+	>(REDUCE_TO_VALUES[2]); // default to avg
 
 	const handleChange = (
 		newValue: SelectOption<ReduceOperators, string>,
 	): void => {
+		setCurrentValue(newValue);
 		onChange(newValue.value);
 	};
 
+	useEffect(
+		() => {
+			if (!isMounted.current) {
+				const reduceToValue =
+					(query.aggregations?.[0] as MetricAggregation)?.reduceTo || query.reduceTo;
+
+				setCurrentValue(
+					REDUCE_TO_VALUES.find((option) => option.value === reduceToValue) ||
+						REDUCE_TO_VALUES[2],
+				);
+				isMounted.current = true;
+				return;
+			}
+
+			const aggregationAttributeType = query.aggregateAttribute?.type as
+				| MetricType
+				| undefined;
+
+			if (aggregationAttributeType === MetricType.SUM) {
+				handleChange(REDUCE_TO_VALUES[1]);
+			} else {
+				handleChange(REDUCE_TO_VALUES[2]);
+			}
+		},
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+		[query.aggregateAttribute?.key],
+	);
+
 	return (
 		<Select
 			placeholder="Reduce to"

frontend/src/container/QueryTable/Drilldown/__tests__/drilldownUtils.test.tsx

@@ -8,6 +8,7 @@ import {
 	getViewQuery,
 	isValidQueryName,
 } from '../drilldownUtils';
+import { METRIC_TO_LOGS_TRACES_MAPPINGS } from '../metricsCorrelationUtils';
 
 // Mock the transformMetricsToLogsTraces function since it's not exported
 // We'll test it indirectly through getViewQuery
@@ -117,6 +118,7 @@ describe('drilldownUtils', () => {
 					{
 						queryName: 'metrics_query',
 						dataSource: 'metrics' as any,
+						aggregations: [{ metricName: 'signoz_test_metric' }] as any,
 						groupBy: [],
 						expression: '',
 						disabled: false,
@@ -144,6 +146,16 @@ describe('drilldownUtils', () => {
 		];
 
 		it('should transform metrics query when drilling down to logs', () => {
+			const mappingsByAttr = Object.fromEntries(
+				METRIC_TO_LOGS_TRACES_MAPPINGS.map((m) => [m.attribute, m]),
+			) as Record<
+				string,
+				{ newAttribute: string; valueMappings: Record<string, string> }
+			>;
+			const spanKindMapping = mappingsByAttr['span.kind'];
+			const spanKindKey = spanKindMapping.newAttribute;
+			const spanKindServer = spanKindMapping.valueMappings.SPAN_KIND_SERVER;
+
 			const result = getViewQuery(
 				mockMetricsQuery,
 				mockFilters,
@@ -161,20 +173,30 @@ describe('drilldownUtils', () => {
 			// Verify transformations were applied
 			if (filterExpression) {
 				// Rule 2: operation → name
-				expect(filterExpression).toContain('name = "GET"');
-				expect(filterExpression).not.toContain('operation = "GET"');
+				expect(filterExpression).toContain(`name = 'GET'`);
+				expect(filterExpression).not.toContain(`operation = 'GET'`);
 
 				// Rule 3: span.kind → kind
-				expect(filterExpression).toContain('kind = 2');
-				expect(filterExpression).not.toContain('span.kind = SPAN_KIND_SERVER');
+				expect(filterExpression).toContain(`${spanKindKey} = '${spanKindServer}'`);
+				expect(filterExpression).not.toContain(`span.kind = SPAN_KIND_SERVER`);
 
 				// Rule 4: status.code → status_code_string with value mapping
-				expect(filterExpression).toContain('status_code_string = Ok');
-				expect(filterExpression).not.toContain('status.code = STATUS_CODE_OK');
+				expect(filterExpression).toContain(`status_code_string = 'Ok'`);
+				expect(filterExpression).not.toContain(`status.code = STATUS_CODE_OK`);
 			}
 		});
 
 		it('should transform metrics query when drilling down to traces', () => {
+			const mappingsByAttr = Object.fromEntries(
+				METRIC_TO_LOGS_TRACES_MAPPINGS.map((m) => [m.attribute, m]),
+			) as Record<
+				string,
+				{ newAttribute: string; valueMappings: Record<string, string> }
+			>;
+			const spanKindMapping = mappingsByAttr['span.kind'];
+			const spanKindKey = spanKindMapping.newAttribute;
+			const spanKindServer = spanKindMapping.valueMappings.SPAN_KIND_SERVER;
+
 			const result = getViewQuery(
 				mockMetricsQuery,
 				mockFilters,
@@ -192,44 +214,30 @@ describe('drilldownUtils', () => {
 			// Verify transformations were applied
 			if (filterExpression) {
 				// Rule 2: operation → name
-				expect(filterExpression).toContain('name = "GET"');
-				expect(filterExpression).not.toContain('operation = "GET"');
+				expect(filterExpression).toContain(`name = 'GET'`);
+				expect(filterExpression).not.toContain(`operation = 'GET'`);
 
 				// Rule 3: span.kind → kind
-				expect(filterExpression).toContain('kind = 2');
-				expect(filterExpression).not.toContain('span.kind = SPAN_KIND_SERVER');
+				expect(filterExpression).toContain(`${spanKindKey} = '${spanKindServer}'`);
+				expect(filterExpression).not.toContain(`span.kind = SPAN_KIND_SERVER`);
 
 				// Rule 4: status.code → status_code_string with value mapping
-				expect(filterExpression).toContain('status_code_string = Ok');
-				expect(filterExpression).not.toContain('status.code = STATUS_CODE_OK');
-			}
-		});
-
-		it('should NOT transform metrics query when drilling down to metrics', () => {
-			const result = getViewQuery(
-				mockMetricsQuery,
-				mockFilters,
-				'view_metrics',
-				'metrics_query',
-			);
-
-			expect(result).not.toBeNull();
-			expect(result?.builder.queryData).toHaveLength(1);
-
-			// Check that the filter expression was NOT transformed
-			const filterExpression = result?.builder.queryData[0]?.filter?.expression;
-			expect(filterExpression).toBeDefined();
-
-			// Verify NO transformations were applied
-			if (filterExpression) {
-				// Should still contain original metric format
-				expect(filterExpression).toContain('operation = "GET"');
-				expect(filterExpression).toContain('span.kind = SPAN_KIND_SERVER');
-				expect(filterExpression).toContain('status.code = STATUS_CODE_OK');
+				expect(filterExpression).toContain(`status_code_string = 'Ok'`);
+				expect(filterExpression).not.toContain(`status.code = STATUS_CODE_OK`);
 			}
 		});
 
 		it('should handle complex filter expressions with multiple transformations', () => {
+			const mappingsByAttr = Object.fromEntries(
+				METRIC_TO_LOGS_TRACES_MAPPINGS.map((m) => [m.attribute, m]),
+			) as Record<
+				string,
+				{ newAttribute: string; valueMappings: Record<string, string> }
+			>;
+			const spanKindMapping = mappingsByAttr['span.kind'];
+			const spanKindKey = spanKindMapping.newAttribute;
+			const spanKindClient = spanKindMapping.valueMappings.SPAN_KIND_CLIENT;
+
 			const complexQuery: Query = {
 				...mockMetricsQuery,
 				builder: {
@@ -258,10 +266,10 @@ describe('drilldownUtils', () => {
 
 			if (filterExpression) {
 				// All transformations should be applied
-				expect(filterExpression).toContain('name = "POST"');
-				expect(filterExpression).toContain('kind = 3');
-				expect(filterExpression).toContain('status_code_string = Error');
-				expect(filterExpression).toContain('http.status_code = 500');
+				expect(filterExpression).toContain(`name = 'POST'`);
+				expect(filterExpression).toContain(`${spanKindKey} = '${spanKindClient}'`);
+				expect(filterExpression).toContain(`status_code_string = 'Error'`);
+				expect(filterExpression).toContain(`http.status_code = 500`);
 			}
 		});
 
@@ -299,13 +307,12 @@ describe('drilldownUtils', () => {
 		});
 
 		it('should handle all status code value mappings correctly', () => {
-			const statusCodeTests = [
-				{ input: 'STATUS_CODE_UNSET', expected: 'Unset' },
-				{ input: 'STATUS_CODE_OK', expected: 'Ok' },
-				{ input: 'STATUS_CODE_ERROR', expected: 'Error' },
-			];
+			const mappingsByAttr = Object.fromEntries(
+				METRIC_TO_LOGS_TRACES_MAPPINGS.map((m) => [m.attribute, m]),
+			) as Record<string, { valueMappings: Record<string, string> }>;
+			const statusMap = mappingsByAttr['status.code'].valueMappings;
 
-			statusCodeTests.forEach(({ input, expected }) => {
+			Object.entries(statusMap).forEach(([input, expected]) => {
 				const testQuery: Query = {
 					...mockMetricsQuery,
 					builder: {
@@ -329,19 +336,18 @@ describe('drilldownUtils', () => {
 				);
 				const filterExpression = result?.builder.queryData[0]?.filter?.expression;
 
-				expect(filterExpression).toContain(`status_code_string = ${expected}`);
+				expect(filterExpression).toContain(`status_code_string = '${expected}'`);
 				expect(filterExpression).not.toContain(`status.code = ${input}`);
 			});
 		});
 
 		it('should handle quoted status code values (browser scenario)', () => {
-			const statusCodeTests = [
-				{ input: '"STATUS_CODE_UNSET"', expected: '"Unset"' },
-				{ input: '"STATUS_CODE_OK"', expected: '"Ok"' },
-				{ input: '"STATUS_CODE_ERROR"', expected: '"Error"' },
-			];
+			const mappingsByAttr = Object.fromEntries(
+				METRIC_TO_LOGS_TRACES_MAPPINGS.map((m) => [m.attribute, m]),
+			) as Record<string, { valueMappings: Record<string, string> }>;
+			const statusMap = mappingsByAttr['status.code'].valueMappings;
 
-			statusCodeTests.forEach(({ input, expected }) => {
+			Object.entries(statusMap).forEach(([input, expected]) => {
 				const testQuery: Query = {
 					...mockMetricsQuery,
 					builder: {
@@ -350,7 +356,7 @@ describe('drilldownUtils', () => {
 							{
 								...mockMetricsQuery.builder.queryData[0],
 								filter: {
-									expression: `status.code = ${input}`,
+									expression: `status.code = "${input}"`,
 								},
 							},
 						],
@@ -366,12 +372,22 @@ describe('drilldownUtils', () => {
 				const filterExpression = result?.builder.queryData[0]?.filter?.expression;
 
 				// Should preserve the quoting from the original expression
-				expect(filterExpression).toContain(`status_code_string = ${expected}`);
-				expect(filterExpression).not.toContain(`status.code = ${input}`);
+				expect(filterExpression).toContain(`status_code_string = '${expected}'`);
+				expect(filterExpression).not.toContain(`status.code = "${input}"`);
 			});
 		});
 
 		it('should preserve non-metric attributes during transformation', () => {
+			const mappingsByAttr = Object.fromEntries(
+				METRIC_TO_LOGS_TRACES_MAPPINGS.map((m) => [m.attribute, m]),
+			) as Record<
+				string,
+				{ newAttribute: string; valueMappings: Record<string, string> }
+			>;
+			const spanKindMapping = mappingsByAttr['span.kind'];
+			const spanKindKey = spanKindMapping.newAttribute;
+			const spanKindServer = spanKindMapping.valueMappings.SPAN_KIND_SERVER;
+
 			const mixedQuery: Query = {
 				...mockMetricsQuery,
 				builder: {
@@ -398,8 +414,8 @@ describe('drilldownUtils', () => {
 
 			if (filterExpression) {
 				// Transformed attributes
-				expect(filterExpression).toContain('name = "GET"');
-				expect(filterExpression).toContain('kind = 2');
+				expect(filterExpression).toContain(`name = 'GET'`);
+				expect(filterExpression).toContain(`${spanKindKey} = '${spanKindServer}'`);
 
 				// Preserved non-metric attributes
 				expect(filterExpression).toContain('service = "test-service"');
@@ -408,15 +424,17 @@ describe('drilldownUtils', () => {
 		});
 
 		it('should handle all span.kind value mappings correctly', () => {
-			const spanKindTests = [
-				{ input: 'SPAN_KIND_INTERNAL', expected: '1' },
-				{ input: 'SPAN_KIND_CONSUMER', expected: '5' },
-				{ input: 'SPAN_KIND_CLIENT', expected: '3' },
-				{ input: 'SPAN_KIND_PRODUCER', expected: '4' },
-				{ input: 'SPAN_KIND_SERVER', expected: '2' },
-			];
+			const mappingsByAttr = Object.fromEntries(
+				METRIC_TO_LOGS_TRACES_MAPPINGS.map((m) => [m.attribute, m]),
+			) as Record<
+				string,
+				{ newAttribute: string; valueMappings: Record<string, string> }
+			>;
+			const spanKindMapping = mappingsByAttr['span.kind'];
+			const spanKindKey = spanKindMapping.newAttribute;
+			const spanKindMap = spanKindMapping.valueMappings;
 
-			spanKindTests.forEach(({ input, expected }) => {
+			Object.entries(spanKindMap).forEach(([input, expected]) => {
 				const testQuery: Query = {
 					...mockMetricsQuery,
 					builder: {
@@ -440,9 +458,48 @@ describe('drilldownUtils', () => {
 				);
 				const filterExpression = result?.builder.queryData[0]?.filter?.expression;
 
-				expect(filterExpression).toContain(`kind = ${expected}`);
+				expect(filterExpression).toContain(`${spanKindKey} = '${expected}'`);
 				expect(filterExpression).not.toContain(`span.kind = ${input}`);
 			});
 		});
+
+		it('should not transform when the source query is not metrics (logs/traces sources)', () => {
+			(['logs', 'traces'] as const).forEach((source) => {
+				const nonMetricsQuery: Query = {
+					...mockMetricsQuery,
+					builder: {
+						...mockMetricsQuery.builder,
+						queryData: [
+							{
+								...mockMetricsQuery.builder.queryData[0],
+								dataSource: source as any,
+								filter: {
+									expression:
+										'operation = "GET" AND span.kind = SPAN_KIND_SERVER AND status.code = STATUS_CODE_OK',
+								},
+							},
+						],
+					},
+				};
+
+				const result = getViewQuery(
+					nonMetricsQuery,
+					mockFilters,
+					source === 'logs' ? 'view_logs' : 'view_traces',
+					'metrics_query',
+				);
+
+				const expr = result?.builder.queryData[0]?.filter?.expression || '';
+				// Should remain unchanged (no metric-to-logs/traces transformations)
+				expect(expr).toContain('operation = "GET"');
+				expect(expr).toContain('span.kind = SPAN_KIND_SERVER');
+				expect(expr).toContain('status.code = STATUS_CODE_OK');
+
+				// And should not contain transformed counterparts
+				expect(expr).not.toContain(`name = 'GET'`);
+				expect(expr).not.toContain(`kind = '2'`);
+				expect(expr).not.toContain(`status_code_string = 'Ok'`);
+			});
+		});
 	});
 });

frontend/src/container/QueryTable/Drilldown/drilldownUtils.tsx

@@ -5,6 +5,11 @@ import {
 	OPERATORS,
 } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
+import { isApmMetric } from 'container/PanelWrapper/utils';
+import {
+	METRIC_TO_LOGS_TRACES_MAPPINGS,
+	replaceKeysAndValuesInExpression,
+} from 'container/QueryTable/Drilldown/metricsCorrelationUtils';
 import cloneDeep from 'lodash-es/cloneDeep';
 import {
 	BaseAutocompleteData,
@@ -15,6 +20,7 @@ import {
 	Query,
 	TagFilterItem,
 } from 'types/api/queryBuilder/queryBuilderData';
+import { MetricAggregation } from 'types/api/v5/queryRange';
 import { v4 as uuid } from 'uuid';
 
 export function getBaseMeta(
@@ -270,125 +276,6 @@ const VIEW_QUERY_MAP: Record<string, IBuilderQuery> = {
 	view_traces: initialQueryBuilderFormValuesMap.traces,
 };
 
-/**
- * TEMP LOGIC - TO BE REMOVED LATER
- * Transforms metric query filters to logs/traces format
- * Applies the following transformations:
- * - Rule 2: operation → name
- * - Rule 3: span.kind → kind
- * - Rule 4: status.code → status_code_string with value mapping
- * - Rule 5: http.status_code type conversion
- */
-const transformMetricsToLogsTraces = (
-	filterExpression: string | undefined,
-): string | undefined => {
-	if (!filterExpression) return filterExpression;
-
-	// ===========================================
-	// MAPPING OBJECTS - ALL TRANSFORMATIONS DEFINED HERE
-	// ===========================================
-	const METRIC_TO_LOGS_TRACES_MAPPINGS = {
-		// Rule 2: operation → name
-		attributeRenames: {
-			operation: 'name',
-		},
-
-		// Rule 3: span.kind → kind with value mapping
-		spanKindMapping: {
-			attribute: 'span.kind',
-			newAttribute: 'kind',
-			valueMappings: {
-				SPAN_KIND_INTERNAL: '1',
-				SPAN_KIND_SERVER: '2',
-				SPAN_KIND_CLIENT: '3',
-				SPAN_KIND_PRODUCER: '4',
-				SPAN_KIND_CONSUMER: '5',
-			},
-		},
-
-		// Rule 4: status.code → status_code_string with value mapping
-		statusCodeMapping: {
-			attribute: 'status.code',
-			newAttribute: 'status_code_string',
-			valueMappings: {
-				// From metrics format → To logs/traces format
-				STATUS_CODE_UNSET: 'Unset',
-				STATUS_CODE_OK: 'Ok',
-				STATUS_CODE_ERROR: 'Error',
-			},
-		},
-
-		// Rule 5: http.status_code type conversion
-		typeConversions: {
-			'http.status_code': 'number',
-		},
-	};
-	// ===========================================
-
-	let transformedExpression = filterExpression;
-
-	// Apply attribute renames
-	Object.entries(METRIC_TO_LOGS_TRACES_MAPPINGS.attributeRenames).forEach(
-		([oldAttr, newAttr]) => {
-			const regex = new RegExp(`\\b${oldAttr}\\b`, 'g');
-			transformedExpression = transformedExpression.replace(regex, newAttr);
-		},
-	);
-
-	// Apply span.kind → kind transformation
-	const { spanKindMapping } = METRIC_TO_LOGS_TRACES_MAPPINGS;
-	if (spanKindMapping) {
-		// Replace attribute name - use word boundaries to avoid partial matches
-		const attrRegex = new RegExp(
-			`\\b${spanKindMapping.attribute.replace(/\./g, '\\.')}\\b`,
-			'g',
-		);
-		transformedExpression = transformedExpression.replace(
-			attrRegex,
-			spanKindMapping.newAttribute,
-		);
-
-		// Replace values
-		Object.entries(spanKindMapping.valueMappings).forEach(
-			([oldValue, newValue]) => {
-				const valueRegex = new RegExp(`\\b${oldValue}\\b`, 'g');
-				transformedExpression = transformedExpression.replace(valueRegex, newValue);
-			},
-		);
-	}
-
-	// Apply status.code → status_code_string transformation
-	const { statusCodeMapping } = METRIC_TO_LOGS_TRACES_MAPPINGS;
-	if (statusCodeMapping) {
-		// Replace attribute name - use word boundaries to avoid partial matches
-		// This prevents http.status_code from being transformed
-		const attrRegex = new RegExp(
-			`\\b${statusCodeMapping.attribute.replace(/\./g, '\\.')}\\b`,
-			'g',
-		);
-		transformedExpression = transformedExpression.replace(
-			attrRegex,
-			statusCodeMapping.newAttribute,
-		);
-
-		// Replace values
-		Object.entries(statusCodeMapping.valueMappings).forEach(
-			([oldValue, newValue]) => {
-				const valueRegex = new RegExp(`\\b${oldValue}\\b`, 'g');
-				transformedExpression = transformedExpression.replace(
-					valueRegex,
-					`${newValue}`,
-				);
-			},
-		);
-	}
-
-	// Note: Type conversions (Rule 5) would need more complex parsing
-	// of the filter expression to implement properly
-
-	return transformedExpression;
-};
-
 export const getViewQuery = (
 	query: Query,
 	filtersToAdd: FilterData[],
@@ -448,9 +335,15 @@ export const getViewQuery = (
 		// TEMP LOGIC - TO BE REMOVED LATER
 		// ===========================================
 		// Apply metric-to-logs/traces transformations
-		if (key === 'view_logs' || key === 'view_traces') {
-			const transformedExpression = transformMetricsToLogsTraces(
-				newFilterExpression?.expression,
+		const specificQuery = getQueryData(query, queryName);
+		const isMetricQuery = specificQuery?.dataSource === 'metrics';
+		const metricName = (specificQuery?.aggregations?.[0] as MetricAggregation)
+			?.metricName;
+
+		if (isMetricQuery && isApmMetric(metricName || '')) {
+			const transformedExpression = replaceKeysAndValuesInExpression(
+				newFilterExpression?.expression || '',
+				METRIC_TO_LOGS_TRACES_MAPPINGS,
 			);
 			newQuery.builder.queryData[0].filter = {
 				expression: transformedExpression || '',