fix: remove the exception checking

* feat: work in progress

* fix: test run success

* fix: in progress

* fix: excluding message from metadata fetch

* test: cleared

* fix: key name in metadata

* fix: uncomment tests

* chore: change to method for staticfields

* fix: remove confusing comments; remove usage of logical keyword

* chore: shift method above business logic

* chore: changes based on review

* fix: comments in metadata_store.go

.github/CODEOWNERS

@@ -1,6 +1,8 @@
 # CODEOWNERS info: https://help.github.com/en/articles/about-code-owners
 
-# Owners are automatically requested for review for PRs that changes code that they own.
+# Owners are automatically requested for review for PRs that changes code
+
+# that they own.
 
 /frontend/ @SigNoz/frontend-maintainers
 
@@ -9,10 +11,8 @@
 /frontend/src/container/OnboardingV2Container/onboarding-configs/onboarding-config-with-links.json @makeavish
 /frontend/src/container/OnboardingV2Container/AddDataSource/AddDataSource.tsx @makeavish
 
-# CI
-/deploy/ @therealpandey
-.github @therealpandey
-go.mod @therealpandey
+/deploy/ @SigNoz/devops
+.github @SigNoz/devops
 
 # Scaffold Owners
 

.github/workflows/mergequeueci.yaml

@@ -1,60 +0,0 @@
-name: mergequeueci
-
-on:
-  pull_request:
-    types:
-      - dequeued
-
-jobs:
-  notify:
-    runs-on: ubuntu-latest
-    if: github.event.pull_request.merged == false
-    steps:
-      - name: alert
-        uses: slackapi/slack-github-action@v2.1.1
-        with:
-          webhook: ${{ secrets.SLACK_MERGE_QUEUE_WEBHOOK }}
-          webhook-type: incoming-webhook
-          payload: |
-            {
-              "text": ":x: PR removed from merge queue",
-              "blocks": [
-                {
-                  "type": "header",
-                  "text": {
-                    "type": "plain_text",
-                    "text": ":x: PR Removed from Merge Queue"
-                  }
-                },
-                {
-                  "type": "section",
-                  "text": {
-                    "type": "mrkdwn",
-                    "text": "*<${{ github.event.pull_request.html_url }}|PR #${{ github.event.pull_request.number }}: ${{ github.event.pull_request.title }}>*"
-                  }
-                },
-                {
-                  "type": "divider"
-                },
-                {
-                  "type": "section",
-                  "fields": [
-                    {
-                      "type": "mrkdwn",
-                      "text": "*Author*\n@${{ github.event.pull_request.user.login }}"
-                    }
-                  ]
-                }
-              ]
-            }
-      - name: comment
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          PR_AUTHOR: ${{ github.event.pull_request.user.login }}
-          PR_URL: ${{ github.event.pull_request.html_url }}
-        run: |
-          gh api repos/${{ github.repository }}/issues/$PR_NUMBER/comments \
-            -f body="> :x: **PR removed from merge queue**
-          >
-          > @$PR_AUTHOR your PR was removed from the merge queue. Fix the issue and re-queue when ready."

cmd/root.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/spf13/cobra"
+	"go.uber.org/zap" //nolint:depguard
 )
 
 var RootCmd = &cobra.Command{
@@ -18,6 +19,12 @@ var RootCmd = &cobra.Command{
 }
 
 func Execute(logger *slog.Logger) {
+	zapLogger := newZapLogger()
+	zap.ReplaceGlobals(zapLogger)
+	defer func() {
+		_ = zapLogger.Sync()
+	}()
+
 	err := RootCmd.Execute()
 	if err != nil {
 		logger.ErrorContext(RootCmd.Context(), "error running command", "error", err)

cmd/zap.go

@@ -0,0 +1,110 @@
+package cmd
+
+import (
+	"context"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"go.uber.org/zap"         //nolint:depguard
+	"go.uber.org/zap/zapcore" //nolint:depguard
+)
+
+// Deprecated: Use `NewLogger` from `pkg/instrumentation` instead.
+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()
+
+	// 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)
+}

deploy/docker-swarm/generator/hotrod/docker-compose.yaml

@@ -0,0 +1,38 @@
+version: "3"
+x-common: &common
+  networks:
+    - signoz-net
+  extra_hosts:
+    - host.docker.internal:host-gateway
+  logging:
+    options:
+      max-size: 50m
+      max-file: "3"
+  deploy:
+    restart_policy:
+      condition: on-failure
+services:
+  hotrod:
+    <<: *common
+    image: jaegertracing/example-hotrod:1.61.0
+    command: [ "all" ]
+    environment:
+      - OTEL_EXPORTER_OTLP_ENDPOINT=http://host.docker.internal:4318  #
+  load-hotrod:
+    <<: *common
+    image: "signoz/locust:1.2.3"
+    environment:
+      ATTACKED_HOST: http://hotrod:8080
+      LOCUST_MODE: standalone
+      NO_PROXY: standalone
+      TASK_DELAY_FROM: 5
+      TASK_DELAY_TO: 30
+      QUIET_MODE: "${QUIET_MODE:-false}"
+      LOCUST_OPTS: "--headless -u 10 -r 1"
+    volumes:
+      - ../../../common/locust-scripts:/locust
+
+networks:
+  signoz-net:
+    name: signoz-net
+    external: true

deploy/docker-swarm/generator/infra/docker-compose.yaml

@@ -0,0 +1,69 @@
+version: "3"
+x-common: &common
+  networks:
+    - signoz-net
+  extra_hosts:
+    - host.docker.internal:host-gateway
+  logging:
+    options:
+      max-size: 50m
+      max-file: "3"
+  deploy:
+    mode: global
+    restart_policy:
+      condition: on-failure
+services:
+  otel-agent:
+    <<: *common
+    image: otel/opentelemetry-collector-contrib:0.111.0
+    command:
+      - --config=/etc/otel-collector-config.yaml
+    volumes:
+      - ./otel-agent-config.yaml:/etc/otel-collector-config.yaml
+      - /:/hostfs:ro
+    environment:
+      - SIGNOZ_COLLECTOR_ENDPOINT=http://host.docker.internal:4317    # In case of external SigNoz or cloud, update the endpoint and access token
+      - OTEL_RESOURCE_ATTRIBUTES=host.name={{.Node.Hostname}},os.type={{.Node.Platform.OS}}
+      # - SIGNOZ_ACCESS_TOKEN="<your-access-token>"
+    # Before exposing the ports, make sure the ports are not used by other services
+    # ports:
+    #   - "4317:4317"
+    #   - "4318:4318"
+  otel-metrics:
+    <<: *common
+    image: otel/opentelemetry-collector-contrib:0.111.0
+    user: 0:0   #  If you have security concerns, you can replace this with your `UID:GID` that has necessary permissions to docker.sock
+    command:
+      - --config=/etc/otel-collector-config.yaml
+    volumes:
+      - ./otel-metrics-config.yaml:/etc/otel-collector-config.yaml
+      - /var/run/docker.sock:/var/run/docker.sock
+    environment:
+      - SIGNOZ_COLLECTOR_ENDPOINT=http://host.docker.internal:4317    # In case of external SigNoz or cloud, update the endpoint and access token
+      - OTEL_RESOURCE_ATTRIBUTES=host.name={{.Node.Hostname}},os.type={{.Node.Platform.OS}}
+      # - SIGNOZ_ACCESS_TOKEN="<your-access-token>"
+    # Before exposing the ports, make sure the ports are not used by other services
+    # ports:
+    #   - "4317:4317"
+    #   - "4318:4318"
+    deploy:
+      mode: replicated
+      replicas: 1
+      placement:
+        constraints:
+          - node.role == manager
+  logspout:
+    <<: *common
+    image: "gliderlabs/logspout:v3.2.14"
+    command: syslog+tcp://otel-agent:2255
+    user: root
+    volumes:
+      - /etc/hostname:/etc/host_hostname:ro
+      - /var/run/docker.sock:/var/run/docker.sock
+    depends_on:
+      - otel-agent
+
+networks:
+  signoz-net:
+    name: signoz-net
+    external: true

deploy/docker-swarm/generator/infra/otel-agent-config.yaml

@@ -0,0 +1,102 @@
+receivers:
+  hostmetrics:
+    collection_interval: 30s
+    root_path: /hostfs
+    scrapers:
+      cpu: {}
+      load: {}
+      memory: {}
+      disk: {}
+      filesystem: {}
+      network: {}
+  otlp:
+    protocols:
+      grpc:
+        endpoint: 0.0.0.0:4317
+      http:
+        endpoint: 0.0.0.0:4318
+  prometheus:
+    config:
+      global:
+        scrape_interval: 60s
+      scrape_configs:
+        - job_name: otel-agent
+          static_configs:
+          - targets:
+              - localhost:8888
+            labels:
+              job_name: otel-agent
+  tcplog/docker:
+    listen_address: "0.0.0.0:2255"
+    operators:
+      - type: regex_parser
+        regex: '^<([0-9]+)>[0-9]+ (?P<timestamp>[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]+)?([zZ]|([\+-])([01]\d|2[0-3]):?([0-5]\d)?)?) (?P<container_id>\S+) (?P<container_name>\S+) [0-9]+ - -( (?P<body>.*))?'
+        timestamp:
+          parse_from: attributes.timestamp
+          layout: '%Y-%m-%dT%H:%M:%S.%LZ'
+      - type: move
+        from: attributes["body"]
+        to: body
+      - type: remove
+        field: attributes.timestamp
+      # please remove names from below if you want to collect logs from them
+      - type: filter
+        id: signoz_logs_filter
+        expr: 'attributes.container_name matches "^(signoz_(logspout|signoz|otel-collector|clickhouse|zookeeper))|(infra_(logspout|otel-agent|otel-metrics)).*"'
+processors:
+  batch:
+    send_batch_size: 10000
+    send_batch_max_size: 11000
+    timeout: 10s
+  resourcedetection:
+    # Using OTEL_RESOURCE_ATTRIBUTES envvar, env detector adds custom labels.
+    detectors:
+      # - ec2
+      # - gcp
+      # - azure
+      - env
+      - system
+    timeout: 2s
+extensions:
+  health_check:
+    endpoint: 0.0.0.0:13133
+  pprof:
+    endpoint: 0.0.0.0:1777
+exporters:
+  otlp:
+    endpoint: ${env:SIGNOZ_COLLECTOR_ENDPOINT}
+    tls:
+      insecure: true
+    headers:
+      signoz-access-token: ${env:SIGNOZ_ACCESS_TOKEN}
+  # debug: {}
+service:
+  telemetry:
+    logs:
+      encoding: json
+    metrics:
+      address: 0.0.0.0:8888
+  extensions:
+    - health_check
+    - pprof
+  pipelines:
+    traces:
+      receivers: [otlp]
+      processors: [resourcedetection, batch]
+      exporters: [otlp]
+    metrics:
+      receivers: [otlp]
+      processors: [resourcedetection, batch]
+      exporters: [otlp]
+    metrics/hostmetrics:
+      receivers: [hostmetrics]
+      processors: [resourcedetection, batch]
+      exporters: [otlp]
+    metrics/prometheus:
+      receivers: [prometheus]
+      processors: [resourcedetection, batch]
+      exporters: [otlp]
+    logs:
+      receivers: [otlp, tcplog/docker]
+      processors: [resourcedetection, batch]
+      exporters: [otlp]

deploy/docker-swarm/generator/infra/otel-metrics-config.yaml

@@ -0,0 +1,103 @@
+receivers:
+  prometheus:
+    config:
+      global:
+        scrape_interval: 60s
+      scrape_configs:
+        - job_name: otel-metrics
+          static_configs:
+          - targets:
+              - localhost:8888
+            labels:
+              job_name: otel-metrics
+        # For Docker daemon metrics to be scraped, it must be configured to expose
+        # Prometheus metrics, as documented here: https://docs.docker.com/config/daemon/prometheus/
+        # - job_name: docker-daemon
+        #   dockerswarm_sd_configs:
+        #     - host: unix:///var/run/docker.sock
+        #       role: nodes
+        #   relabel_configs:
+        #     - source_labels: [__meta_dockerswarm_node_address]
+        #       target_label: __address__
+        #       replacement: $1:9323
+        - job_name: "dockerswarm"
+          dockerswarm_sd_configs:
+            - host: unix:///var/run/docker.sock
+              role: tasks
+          relabel_configs:
+            - action: keep
+              regex: running
+              source_labels:
+                - __meta_dockerswarm_task_desired_state
+            - action: keep
+              regex: true
+              source_labels:
+                - __meta_dockerswarm_service_label_signoz_io_scrape
+            - regex: ([^:]+)(?::\d+)?
+              replacement: $1
+              source_labels:
+                - __address__
+              target_label: swarm_container_ip
+            - separator: .
+              source_labels:
+                - __meta_dockerswarm_service_name
+                - __meta_dockerswarm_task_slot
+                - __meta_dockerswarm_task_id
+              target_label: swarm_container_name
+            - target_label: __address__
+              source_labels:
+                - swarm_container_ip
+                - __meta_dockerswarm_service_label_signoz_io_port
+              separator: ":"
+            - source_labels:
+                - __meta_dockerswarm_service_label_signoz_io_path
+              target_label: __metrics_path__
+            - source_labels:
+              - __meta_dockerswarm_service_label_com_docker_stack_namespace
+              target_label: namespace
+            - source_labels:
+                - __meta_dockerswarm_service_name
+              target_label: service_name
+            - source_labels:
+                - __meta_dockerswarm_task_id
+              target_label: service_instance_id
+            - source_labels:
+                - __meta_dockerswarm_node_hostname
+              target_label: host_name
+processors:
+  batch:
+    send_batch_size: 10000
+    send_batch_max_size: 11000
+    timeout: 10s
+  resourcedetection:
+    detectors:
+      - env
+      - system
+    timeout: 2s
+extensions:
+  health_check:
+    endpoint: 0.0.0.0:13133
+  pprof:
+    endpoint: 0.0.0.0:1777
+exporters:
+  otlp:
+    endpoint: ${env:SIGNOZ_COLLECTOR_ENDPOINT}
+    tls:
+      insecure: true
+    headers:
+      signoz-access-token: ${env:SIGNOZ_ACCESS_TOKEN}
+  # debug: {}
+service:
+  telemetry:
+    logs:
+      encoding: json
+    metrics:
+      address: 0.0.0.0:8888
+  extensions:
+    - health_check
+    - pprof
+  pipelines:
+    metrics:
+      receivers: [prometheus]
+      processors: [resourcedetection, batch]
+      exporters: [otlp]

deploy/docker/generator/hotrod/docker-compose.yaml

@@ -0,0 +1,39 @@
+version: "3"
+x-common: &common
+  networks:
+    - signoz-net
+  extra_hosts:
+    - host.docker.internal:host-gateway
+  logging:
+    options:
+      max-size: 50m
+      max-file: "3"
+  restart: unless-stopped
+services:
+  hotrod:
+    <<: *common
+    image: jaegertracing/example-hotrod:1.61.0
+    container_name: hotrod
+    command: [ "all" ]
+    environment:
+      - OTEL_EXPORTER_OTLP_ENDPOINT=http://host.docker.internal:4318  # In case of external SigNoz or cloud, update the endpoint and access token
+      # - OTEL_OTLP_HEADERS=signoz-access-token=<your-access-token>
+  load-hotrod:
+    <<: *common
+    image: "signoz/locust:1.2.3"
+    container_name: load-hotrod
+    environment:
+      ATTACKED_HOST: http://hotrod:8080
+      LOCUST_MODE: standalone
+      NO_PROXY: standalone
+      TASK_DELAY_FROM: 5
+      TASK_DELAY_TO: 30
+      QUIET_MODE: "${QUIET_MODE:-false}"
+      LOCUST_OPTS: "--headless -u 10 -r 1"
+    volumes:
+      - ../../../common/locust-scripts:/locust
+
+networks:
+  signoz-net:
+    name: signoz-net
+    external: true

deploy/docker/generator/infra/docker-compose.yaml

@@ -0,0 +1,43 @@
+version: "3"
+x-common: &common
+  networks:
+    - signoz-net
+  extra_hosts:
+    - host.docker.internal:host-gateway
+  logging:
+    options:
+      max-size: 50m
+      max-file: "3"
+  restart: unless-stopped
+services:
+  otel-agent:
+    <<: *common
+    image: otel/opentelemetry-collector-contrib:0.111.0
+    command:
+      - --config=/etc/otel-collector-config.yaml
+    volumes:
+      - ./otel-collector-config.yaml:/etc/otel-collector-config.yaml
+      - /:/hostfs:ro
+      - /var/run/docker.sock:/var/run/docker.sock
+    environment:
+      - SIGNOZ_COLLECTOR_ENDPOINT=http://host.docker.internal:4317    # In case of external SigNoz or cloud, update the endpoint and access token
+      - OTEL_RESOURCE_ATTRIBUTES=host.name=signoz-host,os.type=linux  # Replace signoz-host with the actual hostname
+      # - SIGNOZ_ACCESS_TOKEN="<your-access-token>"
+    # Before exposing the ports, make sure the ports are not used by other services
+    # ports:
+    #   - "4317:4317"
+    #   - "4318:4318"
+  logspout:
+    <<: *common
+    image: "gliderlabs/logspout:v3.2.14"
+    volumes:
+      - /etc/hostname:/etc/host_hostname:ro
+      - /var/run/docker.sock:/var/run/docker.sock
+    command: syslog+tcp://otel-agent:2255
+    depends_on:
+      - otel-agent
+
+networks:
+  signoz-net:
+    name: signoz-net
+    external: true

deploy/docker/generator/infra/otel-collector-config.yaml

@@ -0,0 +1,139 @@
+receivers:
+  hostmetrics:
+    collection_interval: 30s
+    root_path: /hostfs
+    scrapers:
+      cpu: {}
+      load: {}
+      memory: {}
+      disk: {}
+      filesystem: {}
+      network: {}
+  otlp:
+    protocols:
+      grpc:
+        endpoint: 0.0.0.0:4317
+      http:
+        endpoint: 0.0.0.0:4318
+  prometheus:
+    config:
+      global:
+        scrape_interval: 60s
+      scrape_configs:
+        - job_name: otel-collector
+          static_configs:
+          - targets:
+              - localhost:8888
+            labels:
+              job_name: otel-collector
+        # For Docker daemon metrics to be scraped, it must be configured to expose
+        # Prometheus metrics, as documented here: https://docs.docker.com/config/daemon/prometheus/
+        # - job_name: docker-daemon
+        #   static_configs:
+        #   - targets:
+        #       - host.docker.internal:9323
+        #     labels:
+        #       job_name: docker-daemon
+        - job_name: docker-container
+          docker_sd_configs:
+            - host: unix:///var/run/docker.sock
+          relabel_configs:
+            - action: keep
+              regex: true
+              source_labels:
+                - __meta_docker_container_label_signoz_io_scrape
+            - regex: true
+              source_labels:
+                - __meta_docker_container_label_signoz_io_path
+              target_label: __metrics_path__
+            - regex: (.+)
+              source_labels:
+                - __meta_docker_container_label_signoz_io_path
+              target_label: __metrics_path__
+            - separator: ":"
+              source_labels:
+                - __meta_docker_network_ip
+                - __meta_docker_container_label_signoz_io_port
+              target_label: __address__
+            - regex: '/(.*)'
+              replacement: '$1'
+              source_labels:
+                - __meta_docker_container_name
+              target_label: container_name
+            - regex: __meta_docker_container_label_signoz_io_(.+)
+              action: labelmap
+              replacement: $1
+  tcplog/docker:
+    listen_address: "0.0.0.0:2255"
+    operators:
+      - type: regex_parser
+        regex: '^<([0-9]+)>[0-9]+ (?P<timestamp>[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]+)?([zZ]|([\+-])([01]\d|2[0-3]):?([0-5]\d)?)?) (?P<container_id>\S+) (?P<container_name>\S+) [0-9]+ - -( (?P<body>.*))?'
+        timestamp:
+          parse_from: attributes.timestamp
+          layout: '%Y-%m-%dT%H:%M:%S.%LZ'
+      - type: move
+        from: attributes["body"]
+        to: body
+      - type: remove
+        field: attributes.timestamp
+      # please remove names from below if you want to collect logs from them
+      - type: filter
+        id: signoz_logs_filter
+        expr: 'attributes.container_name matches "^signoz|(signoz-(|otel-collector|clickhouse|zookeeper))|(infra-(logspout|otel-agent)-.*)"'
+processors:
+  batch:
+    send_batch_size: 10000
+    send_batch_max_size: 11000
+    timeout: 10s
+  resourcedetection:
+    # Using OTEL_RESOURCE_ATTRIBUTES envvar, env detector adds custom labels.
+    detectors:
+      # - ec2
+      # - gcp
+      # - azure
+      - env
+      - system
+    timeout: 2s
+extensions:
+  health_check:
+    endpoint: 0.0.0.0:13133
+  pprof:
+    endpoint: 0.0.0.0:1777
+exporters:
+  otlp:
+    endpoint: ${env:SIGNOZ_COLLECTOR_ENDPOINT}
+    tls:
+      insecure: true
+    headers:
+      signoz-access-token: ${env:SIGNOZ_ACCESS_TOKEN}
+  # debug: {}
+service:
+  telemetry:
+    logs:
+      encoding: json
+    metrics:
+      address: 0.0.0.0:8888
+  extensions:
+    - health_check
+    - pprof
+  pipelines:
+    traces:
+      receivers: [otlp]
+      processors: [resourcedetection, batch]
+      exporters: [otlp]
+    metrics:
+      receivers: [otlp]
+      processors: [resourcedetection, batch]
+      exporters: [otlp]
+    metrics/hostmetrics:
+      receivers: [hostmetrics]
+      processors: [resourcedetection, batch]
+      exporters: [otlp]
+    metrics/prometheus:
+      receivers: [prometheus]
+      processors: [resourcedetection, batch]
+      exporters: [otlp]
+    logs:
+      receivers: [otlp, tcplog/docker]
+      processors: [resourcedetection, batch]
+      exporters: [otlp]

ee/query-service/anomaly/seasonal.go

@@ -2,7 +2,6 @@ package anomaly
 
 import (
 	"context"
-	"log/slog"
 	"math"
 	"time"
 
@@ -14,6 +13,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	"github.com/SigNoz/signoz/pkg/types/instrumentationtypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
+	"go.uber.org/zap"
 )
 
 var (
@@ -67,7 +67,7 @@ func (p *BaseSeasonalProvider) getResults(ctx context.Context, orgID valuer.UUID
 		instrumentationtypes.CodeNamespace:    "anomaly",
 		instrumentationtypes.CodeFunctionName: "getResults",
 	})
-	slog.InfoContext(ctx, "fetching results for current period", "current_period_query", params.CurrentPeriodQuery)
+	zap.L().Info("fetching results for current period", zap.Any("currentPeriodQuery", params.CurrentPeriodQuery))
 	currentPeriodResults, _, err := p.querierV2.QueryRange(ctx, orgID, params.CurrentPeriodQuery)
 	if err != nil {
 		return nil, err
@@ -78,7 +78,7 @@ func (p *BaseSeasonalProvider) getResults(ctx context.Context, orgID valuer.UUID
 		return nil, err
 	}
 
-	slog.InfoContext(ctx, "fetching results for past period", "past_period_query", params.PastPeriodQuery)
+	zap.L().Info("fetching results for past period", zap.Any("pastPeriodQuery", params.PastPeriodQuery))
 	pastPeriodResults, _, err := p.querierV2.QueryRange(ctx, orgID, params.PastPeriodQuery)
 	if err != nil {
 		return nil, err
@@ -89,7 +89,7 @@ func (p *BaseSeasonalProvider) getResults(ctx context.Context, orgID valuer.UUID
 		return nil, err
 	}
 
-	slog.InfoContext(ctx, "fetching results for current season", "current_season_query", params.CurrentSeasonQuery)
+	zap.L().Info("fetching results for current season", zap.Any("currentSeasonQuery", params.CurrentSeasonQuery))
 	currentSeasonResults, _, err := p.querierV2.QueryRange(ctx, orgID, params.CurrentSeasonQuery)
 	if err != nil {
 		return nil, err
@@ -100,7 +100,7 @@ func (p *BaseSeasonalProvider) getResults(ctx context.Context, orgID valuer.UUID
 		return nil, err
 	}
 
-	slog.InfoContext(ctx, "fetching results for past season", "past_season_query", params.PastSeasonQuery)
+	zap.L().Info("fetching results for past season", zap.Any("pastSeasonQuery", params.PastSeasonQuery))
 	pastSeasonResults, _, err := p.querierV2.QueryRange(ctx, orgID, params.PastSeasonQuery)
 	if err != nil {
 		return nil, err
@@ -111,7 +111,7 @@ func (p *BaseSeasonalProvider) getResults(ctx context.Context, orgID valuer.UUID
 		return nil, err
 	}
 
-	slog.InfoContext(ctx, "fetching results for past 2 season", "past_2_season_query", params.Past2SeasonQuery)
+	zap.L().Info("fetching results for past 2 season", zap.Any("past2SeasonQuery", params.Past2SeasonQuery))
 	past2SeasonResults, _, err := p.querierV2.QueryRange(ctx, orgID, params.Past2SeasonQuery)
 	if err != nil {
 		return nil, err
@@ -122,7 +122,7 @@ func (p *BaseSeasonalProvider) getResults(ctx context.Context, orgID valuer.UUID
 		return nil, err
 	}
 
-	slog.InfoContext(ctx, "fetching results for past 3 season", "past_3_season_query", params.Past3SeasonQuery)
+	zap.L().Info("fetching results for past 3 season", zap.Any("past3SeasonQuery", params.Past3SeasonQuery))
 	past3SeasonResults, _, err := p.querierV2.QueryRange(ctx, orgID, params.Past3SeasonQuery)
 	if err != nil {
 		return nil, err
@@ -235,17 +235,17 @@ func (p *BaseSeasonalProvider) getPredictedSeries(
 		if predictedValue < 0 {
 			// this should not happen (except when the data has extreme outliers)
 			// we will use the moving avg of the previous period series in this case
-			slog.Warn("predicted value is less than 0", "predicted_value", predictedValue, "labels", series.Labels)
+			zap.L().Warn("predictedValue is less than 0", zap.Float64("predictedValue", predictedValue), zap.Any("labels", series.Labels))
 			predictedValue = p.getMovingAvg(prevSeries, movingAvgWindowSize, idx)
 		}
 
-		slog.Debug("predicted series",
-			"moving_avg", movingAvg,
-			"avg", avg,
-			"mean", mean,
-			"labels", series.Labels,
-			"predicted_value", predictedValue,
-			"curr", curr.Value,
+		zap.L().Debug("predictedSeries",
+			zap.Float64("movingAvg", movingAvg),
+			zap.Float64("avg", avg),
+			zap.Float64("mean", mean),
+			zap.Any("labels", series.Labels),
+			zap.Float64("predictedValue", predictedValue),
+			zap.Float64("curr", curr.Value),
 		)
 		predictedSeries.Points = append(predictedSeries.Points, v3.Point{
 			Timestamp: curr.Timestamp,
@@ -418,7 +418,7 @@ func (p *BaseSeasonalProvider) getAnomalies(ctx context.Context, orgID valuer.UU
 
 		for _, series := range result.Series {
 			stdDev := p.getStdDev(series)
-			slog.InfoContext(ctx, "computed standard deviation", "std_dev", stdDev, "labels", series.Labels)
+			zap.L().Info("stdDev", zap.Float64("stdDev", stdDev), zap.Any("labels", series.Labels))
 
 			pastPeriodSeries := p.getMatchingSeries(pastPeriodResult, series)
 			currentSeasonSeries := p.getMatchingSeries(currentSeasonResult, series)
@@ -431,7 +431,7 @@ func (p *BaseSeasonalProvider) getAnomalies(ctx context.Context, orgID valuer.UU
 			pastSeasonSeriesAvg := p.getAvg(pastSeasonSeries)
 			past2SeasonSeriesAvg := p.getAvg(past2SeasonSeries)
 			past3SeasonSeriesAvg := p.getAvg(past3SeasonSeries)
-			slog.InfoContext(ctx, "computed averages", "prev_series_avg", prevSeriesAvg, "current_season_series_avg", currentSeasonSeriesAvg, "past_season_series_avg", pastSeasonSeriesAvg, "past_2_season_series_avg", past2SeasonSeriesAvg, "past_3_season_series_avg", past3SeasonSeriesAvg, "labels", series.Labels)
+			zap.L().Info("getAvg", zap.Float64("prevSeriesAvg", prevSeriesAvg), zap.Float64("currentSeasonSeriesAvg", currentSeasonSeriesAvg), zap.Float64("pastSeasonSeriesAvg", pastSeasonSeriesAvg), zap.Float64("past2SeasonSeriesAvg", past2SeasonSeriesAvg), zap.Float64("past3SeasonSeriesAvg", past3SeasonSeriesAvg), zap.Any("labels", series.Labels))
 
 			predictedSeries := p.getPredictedSeries(
 				series,

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

@@ -18,7 +18,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/gorilla/mux"
-	"log/slog"
+	"go.uber.org/zap"
 )
 
 type CloudIntegrationConnectionParamsResponse struct {
@@ -71,7 +71,7 @@ func (ah *APIHandler) CloudIntegrationsGenerateConnectionParams(w http.ResponseW
 		// Return the API Key (PAT) even if the rest of the params can not be deduced.
 		// Params not returned from here will be requested from the user via form inputs.
 		// This enables gracefully degraded but working experience even for non-cloud deployments.
-		slog.InfoContext(r.Context(), "ingestion params and signoz api url can not be deduced since no license was found")
+		zap.L().Info("ingestion params and signoz api url can not be deduced since no license was found")
 		ah.Respond(w, result)
 		return
 	}
@@ -103,7 +103,7 @@ func (ah *APIHandler) CloudIntegrationsGenerateConnectionParams(w http.ResponseW
 		result.IngestionKey = ingestionKey
 
 	} else {
-		slog.InfoContext(r.Context(), "ingestion key can't be deduced since no gateway url has been configured")
+		zap.L().Info("ingestion key can't be deduced since no gateway url has been configured")
 	}
 
 	ah.Respond(w, result)
@@ -138,8 +138,9 @@ func (ah *APIHandler) getOrCreateCloudIntegrationPAT(ctx context.Context, orgId
 		}
 	}
 
-	slog.InfoContext(ctx, "no PAT found for cloud integration, creating a new one",
-		"cloud_provider", cloudProvider,
+	zap.L().Info(
+		"no PAT found for cloud integration, creating a new one",
+		zap.String("cloudProvider", cloudProvider),
 	)
 
 	newPAT, err := types.NewStorableAPIKey(
@@ -286,8 +287,9 @@ func getOrCreateCloudProviderIngestionKey(
 		}
 	}
 
-	slog.InfoContext(ctx, "no existing ingestion key found for cloud integration, creating a new one",
-		"cloud_provider", cloudProvider,
+	zap.L().Info(
+		"no existing ingestion key found for cloud integration, creating a new one",
+		zap.String("cloudProvider", cloudProvider),
 	)
 	createKeyResult, apiErr := requestGateway[createIngestionKeyResponse](
 		ctx, gatewayUrl, licenseKey, "/v1/workspaces/me/keys",

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

@@ -15,7 +15,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/featuretypes"
 	"github.com/SigNoz/signoz/pkg/types/licensetypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
-	"log/slog"
+	"go.uber.org/zap"
 )
 
 func (ah *APIHandler) getFeatureFlags(w http.ResponseWriter, r *http.Request) {
@@ -35,23 +35,23 @@ func (ah *APIHandler) getFeatureFlags(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if constants.FetchFeatures == "true" {
-		slog.DebugContext(ctx, "fetching license")
+		zap.L().Debug("fetching license")
 		license, err := ah.Signoz.Licensing.GetActive(ctx, orgID)
 		if err != nil {
-			slog.ErrorContext(ctx, "failed to fetch license", "error", err)
+			zap.L().Error("failed to fetch license", zap.Error(err))
 		} else if license == nil {
-			slog.DebugContext(ctx, "no active license found")
+			zap.L().Debug("no active license found")
 		} else {
 			licenseKey := license.Key
 
-			slog.DebugContext(ctx, "fetching zeus features")
+			zap.L().Debug("fetching zeus features")
 			zeusFeatures, err := fetchZeusFeatures(constants.ZeusFeaturesURL, licenseKey)
 			if err == nil {
-				slog.DebugContext(ctx, "fetched zeus features", "features", zeusFeatures)
+				zap.L().Debug("fetched zeus features", zap.Any("features", zeusFeatures))
 				// merge featureSet and zeusFeatures in featureSet with higher priority to zeusFeatures
 				featureSet = MergeFeatureSets(zeusFeatures, featureSet)
 			} else {
-				slog.ErrorContext(ctx, "failed to fetch zeus features", "error", err)
+				zap.L().Error("failed to fetch zeus features", zap.Error(err))
 			}
 		}
 	}

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

@@ -14,7 +14,7 @@ import (
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
-	"log/slog"
+	"go.uber.org/zap"
 )
 
 func (aH *APIHandler) queryRangeV4(w http.ResponseWriter, r *http.Request) {
@@ -35,7 +35,7 @@ func (aH *APIHandler) queryRangeV4(w http.ResponseWriter, r *http.Request) {
 	queryRangeParams, apiErrorObj := baseapp.ParseQueryRangeParams(r)
 
 	if apiErrorObj != nil {
-		slog.ErrorContext(r.Context(), "error parsing metric query range params", "error", apiErrorObj.Err)
+		zap.L().Error("error parsing metric query range params", zap.Error(apiErrorObj.Err))
 		RespondError(w, apiErrorObj, nil)
 		return
 	}
@@ -44,7 +44,7 @@ func (aH *APIHandler) queryRangeV4(w http.ResponseWriter, r *http.Request) {
 	// add temporality for each metric
 	temporalityErr := aH.PopulateTemporality(r.Context(), orgID, queryRangeParams)
 	if temporalityErr != nil {
-		slog.ErrorContext(r.Context(), "error while adding temporality for metrics", "error", temporalityErr)
+		zap.L().Error("Error while adding temporality for metrics", zap.Error(temporalityErr))
 		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: temporalityErr}, nil)
 		return
 	}

ee/query-service/app/server.go

@@ -47,7 +47,7 @@ import (
 	baseint "github.com/SigNoz/signoz/pkg/query-service/interfaces"
 	baserules "github.com/SigNoz/signoz/pkg/query-service/rules"
 	"github.com/SigNoz/signoz/pkg/query-service/utils"
-	"log/slog"
+	"go.uber.org/zap"
 )
 
 // Server runs HTTP, Mux and a grpc server
@@ -83,7 +83,6 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 	}
 
 	reader := clickhouseReader.NewReader(
-		signoz.Instrumentation.Logger(),
 		signoz.SQLStore,
 		signoz.TelemetryStore,
 		signoz.Prometheus,
@@ -279,7 +278,7 @@ func (s *Server) initListeners() error {
 		return err
 	}
 
-	slog.Info(fmt.Sprintf("Query server started listening on %s...", s.httpHostPort))
+	zap.L().Info(fmt.Sprintf("Query server started listening on %s...", s.httpHostPort))
 
 	return nil
 }
@@ -299,31 +298,31 @@ func (s *Server) Start(ctx context.Context) error {
 	}
 
 	go func() {
-		slog.Info("Starting HTTP server", "port", httpPort, "addr", s.httpHostPort)
+		zap.L().Info("Starting HTTP server", zap.Int("port", httpPort), zap.String("addr", s.httpHostPort))
 
 		switch err := s.httpServer.Serve(s.httpConn); err {
 		case nil, http.ErrServerClosed, cmux.ErrListenerClosed:
 			// normal exit, nothing to do
 		default:
-			slog.Error("Could not start HTTP server", "error", err)
+			zap.L().Error("Could not start HTTP server", zap.Error(err))
 		}
 		s.unavailableChannel <- healthcheck.Unavailable
 	}()
 
 	go func() {
-		slog.Info("Starting pprof server", "addr", baseconst.DebugHttpPort)
+		zap.L().Info("Starting pprof server", zap.String("addr", baseconst.DebugHttpPort))
 
 		err = http.ListenAndServe(baseconst.DebugHttpPort, nil)
 		if err != nil {
-			slog.Error("Could not start pprof server", "error", err)
+			zap.L().Error("Could not start pprof server", zap.Error(err))
 		}
 	}()
 
 	go func() {
-		slog.Info("Starting OpAmp Websocket server", "addr", baseconst.OpAmpWsEndpoint)
+		zap.L().Info("Starting OpAmp Websocket server", zap.String("addr", baseconst.OpAmpWsEndpoint))
 		err := s.opampServer.Start(baseconst.OpAmpWsEndpoint)
 		if err != nil {
-			slog.Error("opamp ws server failed to start", "error", err)
+			zap.L().Error("opamp ws server failed to start", zap.Error(err))
 			s.unavailableChannel <- healthcheck.Unavailable
 		}
 	}()
@@ -359,9 +358,10 @@ func makeRulesManager(ch baseint.Reader, cache cache.Cache, alertmanager alertma
 		MetadataStore:       metadataStore,
 		Prometheus:          prometheus,
 		Context:             context.Background(),
+		Logger:              zap.L(),
 		Reader:              ch,
 		Querier:             querier,
-		Logger:              providerSettings.Logger,
+		SLogger:             providerSettings.Logger,
 		Cache:               cache,
 		EvalDelay:           baseconst.GetEvalDelay(),
 		PrepareTaskFunc:     rules.PrepareTaskFunc,
@@ -380,7 +380,7 @@ func makeRulesManager(ch baseint.Reader, cache cache.Cache, alertmanager alertma
 		return nil, fmt.Errorf("rule manager error: %v", err)
 	}
 
-	slog.Info("rules manager is ready")
+	zap.L().Info("rules manager is ready")
 
 	return manager, nil
 }

ee/query-service/rules/anomaly_test.go

@@ -2,7 +2,6 @@ package rules
 
 import (
 	"context"
-	"log/slog"
 	"testing"
 	"time"
 
@@ -117,7 +116,7 @@ func TestAnomalyRule_NoData_AlertOnAbsent(t *testing.T) {
 
 			telemetryStore := telemetrystoretest.New(telemetrystore.Config{}, nil)
 			options := clickhouseReader.NewOptions("primaryNamespace")
-			reader := clickhouseReader.NewReader(slog.Default(), nil, telemetryStore, nil, "", time.Second, nil, nil, options)
+			reader := clickhouseReader.NewReader(nil, telemetryStore, nil, "", time.Second, nil, nil, options)
 
 			rule, err := NewAnomalyRule(
 				"test-anomaly-rule",
@@ -248,7 +247,7 @@ func TestAnomalyRule_NoData_AbsentFor(t *testing.T) {
 
 			telemetryStore := telemetrystoretest.New(telemetrystore.Config{}, nil)
 			options := clickhouseReader.NewOptions("primaryNamespace")
-			reader := clickhouseReader.NewReader(slog.Default(), nil, telemetryStore, nil, "", time.Second, nil, nil, options)
+			reader := clickhouseReader.NewReader(nil, telemetryStore, nil, "", time.Second, nil, nil, options)
 
 			rule, err := NewAnomalyRule("test-anomaly-rule", valuer.GenerateUUID(), &postableRule, reader, nil, logger, nil)
 			require.NoError(t, err)

ee/query-service/rules/manager.go

@@ -13,7 +13,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/google/uuid"
-	"log/slog"
+	"go.uber.org/zap"
 )
 
 func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error) {
@@ -34,7 +34,7 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 			opts.Rule,
 			opts.Reader,
 			opts.Querier,
-			opts.Logger,
+			opts.SLogger,
 			baserules.WithEvalDelay(opts.ManagerOpts.EvalDelay),
 			baserules.WithSQLStore(opts.SQLStore),
 			baserules.WithQueryParser(opts.ManagerOpts.QueryParser),
@@ -57,7 +57,7 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 			ruleId,
 			opts.OrgID,
 			opts.Rule,
-			opts.Logger,
+			opts.SLogger,
 			opts.Reader,
 			opts.ManagerOpts.Prometheus,
 			baserules.WithSQLStore(opts.SQLStore),
@@ -82,7 +82,7 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 			opts.Rule,
 			opts.Reader,
 			opts.Querier,
-			opts.Logger,
+			opts.SLogger,
 			opts.Cache,
 			baserules.WithEvalDelay(opts.ManagerOpts.EvalDelay),
 			baserules.WithSQLStore(opts.SQLStore),
@@ -142,7 +142,7 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, *basemodel.Ap
 			parsedRule,
 			opts.Reader,
 			opts.Querier,
-			opts.Logger,
+			opts.SLogger,
 			baserules.WithSendAlways(),
 			baserules.WithSendUnmatched(),
 			baserules.WithSQLStore(opts.SQLStore),
@@ -151,7 +151,7 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, *basemodel.Ap
 		)
 
 		if err != nil {
-			slog.Error("failed to prepare a new threshold rule for test", "name", alertname, "error", err)
+			zap.L().Error("failed to prepare a new threshold rule for test", zap.String("name", alertname), zap.Error(err))
 			return 0, basemodel.BadRequest(err)
 		}
 
@@ -162,7 +162,7 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, *basemodel.Ap
 			alertname,
 			opts.OrgID,
 			parsedRule,
-			opts.Logger,
+			opts.SLogger,
 			opts.Reader,
 			opts.ManagerOpts.Prometheus,
 			baserules.WithSendAlways(),
@@ -173,7 +173,7 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, *basemodel.Ap
 		)
 
 		if err != nil {
-			slog.Error("failed to prepare a new promql rule for test", "name", alertname, "error", err)
+			zap.L().Error("failed to prepare a new promql rule for test", zap.String("name", alertname), zap.Error(err))
 			return 0, basemodel.BadRequest(err)
 		}
 	} else if parsedRule.RuleType == ruletypes.RuleTypeAnomaly {
@@ -184,7 +184,7 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, *basemodel.Ap
 			parsedRule,
 			opts.Reader,
 			opts.Querier,
-			opts.Logger,
+			opts.SLogger,
 			opts.Cache,
 			baserules.WithSendAlways(),
 			baserules.WithSendUnmatched(),
@@ -193,7 +193,7 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, *basemodel.Ap
 			baserules.WithMetadataStore(opts.ManagerOpts.MetadataStore),
 		)
 		if err != nil {
-			slog.Error("failed to prepare a new anomaly rule for test", "name", alertname, "error", err)
+			zap.L().Error("failed to prepare a new anomaly rule for test", zap.String("name", alertname), zap.Error(err))
 			return 0, basemodel.BadRequest(err)
 		}
 	} else {
@@ -205,7 +205,7 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, *basemodel.Ap
 
 	alertsFound, err := rule.Eval(ctx, ts)
 	if err != nil {
-		slog.Error("evaluating rule failed", "rule", rule.Name(), "error", err)
+		zap.L().Error("evaluating rule failed", zap.String("rule", rule.Name()), zap.Error(err))
 		return 0, basemodel.InternalError(fmt.Errorf("rule evaluation failed"))
 	}
 	rule.SendAlerts(ctx, ts, 0, time.Minute, opts.NotifyFunc)

ee/query-service/usage/manager.go

@@ -8,12 +8,12 @@ import (
 	"sync/atomic"
 	"time"
 
-	"log/slog"
-
 	"github.com/ClickHouse/clickhouse-go/v2"
 	"github.com/go-co-op/gocron"
 	"github.com/google/uuid"
 
+	"go.uber.org/zap"
+
 	"github.com/SigNoz/signoz/ee/query-service/model"
 	"github.com/SigNoz/signoz/pkg/licensing"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
@@ -76,19 +76,19 @@ func (lm *Manager) Start(ctx context.Context) error {
 func (lm *Manager) UploadUsage(ctx context.Context) {
 	organizations, err := lm.orgGetter.ListByOwnedKeyRange(ctx)
 	if err != nil {
-		slog.ErrorContext(ctx, "failed to get organizations", "error", err)
+		zap.L().Error("failed to get organizations", zap.Error(err))
 		return
 	}
 	for _, organization := range organizations {
 		// check if license is present or not
 		license, err := lm.licenseService.GetActive(ctx, organization.ID)
 		if err != nil {
-			slog.ErrorContext(ctx, "failed to get active license", "error", err)
+			zap.L().Error("failed to get active license", zap.Error(err))
 			return
 		}
 		if license == nil {
 			// we will not start the usage reporting if license is not present.
-			slog.InfoContext(ctx, "no license present, skipping usage reporting")
+			zap.L().Info("no license present, skipping usage reporting")
 			return
 		}
 
@@ -115,7 +115,7 @@ func (lm *Manager) UploadUsage(ctx context.Context) {
 			dbusages := []model.UsageDB{}
 			err := lm.clickhouseConn.Select(ctx, &dbusages, fmt.Sprintf(query, db, db), time.Now().Add(-(24 * time.Hour)))
 			if err != nil && !strings.Contains(err.Error(), "doesn't exist") {
-				slog.ErrorContext(ctx, "failed to get usage from clickhouse", "error", err)
+				zap.L().Error("failed to get usage from clickhouse: %v", zap.Error(err))
 				return
 			}
 			for _, u := range dbusages {
@@ -125,24 +125,24 @@ func (lm *Manager) UploadUsage(ctx context.Context) {
 		}
 
 		if len(usages) <= 0 {
-			slog.InfoContext(ctx, "no snapshots to upload, skipping")
+			zap.L().Info("no snapshots to upload, skipping.")
 			return
 		}
 
-		slog.InfoContext(ctx, "uploading usage data")
+		zap.L().Info("uploading usage data")
 
 		usagesPayload := []model.Usage{}
 		for _, usage := range usages {
 			usageDataBytes, err := encryption.Decrypt([]byte(usage.ExporterID[:32]), []byte(usage.Data))
 			if err != nil {
-				slog.ErrorContext(ctx, "error while decrypting usage data", "error", err)
+				zap.L().Error("error while decrypting usage data: %v", zap.Error(err))
 				return
 			}
 
 			usageData := model.Usage{}
 			err = json.Unmarshal(usageDataBytes, &usageData)
 			if err != nil {
-				slog.ErrorContext(ctx, "error while unmarshalling usage data", "error", err)
+				zap.L().Error("error while unmarshalling usage data: %v", zap.Error(err))
 				return
 			}
 
@@ -163,13 +163,13 @@ func (lm *Manager) UploadUsage(ctx context.Context) {
 
 		body, errv2 := json.Marshal(payload)
 		if errv2 != nil {
-			slog.ErrorContext(ctx, "error while marshalling usage payload", "error", errv2)
+			zap.L().Error("error while marshalling usage payload: %v", zap.Error(errv2))
 			return
 		}
 
 		errv2 = lm.zeus.PutMeters(ctx, payload.LicenseKey.String(), body)
 		if errv2 != nil {
-			slog.ErrorContext(ctx, "failed to upload usage", "error", errv2)
+			zap.L().Error("failed to upload usage: %v", zap.Error(errv2))
 			// not returning error here since it is captured in the failed count
 			return
 		}
@@ -179,7 +179,7 @@ func (lm *Manager) UploadUsage(ctx context.Context) {
 func (lm *Manager) Stop(ctx context.Context) {
 	lm.scheduler.Stop()
 
-	slog.InfoContext(ctx, "sending usage data before shutting down")
+	zap.L().Info("sending usage data before shutting down")
 	// send usage before shutting down
 	lm.UploadUsage(ctx)
 	atomic.StoreUint32(&locker, stateUnlocked)

ee/sqlschema/postgressqlschema/provider.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"database/sql"
 
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/sqlschema"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
@@ -33,9 +32,9 @@ func New(ctx context.Context, providerSettings factory.ProviderSettings, config
 		fmter:    fmter,
 		settings: settings,
 		operator: sqlschema.NewOperator(fmter, sqlschema.OperatorSupport{
-			SCreateAndDropConstraint:                        true,
-			SAlterTableAddAndDropColumnIfNotExistsAndExists: true,
-			SAlterTableAlterColumnSetAndDrop:                true,
+			DropConstraint:          true,
+			ColumnIfNotExistsExists: true,
+			AlterColumnSetNotNull:   true,
 		}),
 	}, nil
 }
@@ -73,9 +72,8 @@ WHERE
 	if err != nil {
 		return nil, nil, err
 	}
-
 	if len(columns) == 0 {
-		return nil, nil, provider.sqlstore.WrapNotFoundErrf(sql.ErrNoRows, errors.CodeNotFound, "table (%s) not found", tableName)
+		return nil, nil, sql.ErrNoRows
 	}
 
 	sqlschemaColumns := make([]*sqlschema.Column, 0)
@@ -222,9 +220,7 @@ SELECT
     ci.relname AS index_name,
     i.indisunique AS unique,
     i.indisprimary AS primary,
-    a.attname AS column_name,
-    array_position(i.indkey, a.attnum) AS column_position,
-    pg_get_expr(i.indpred, i.indrelid) AS predicate
+    a.attname AS column_name
 FROM
     pg_index i
     LEFT JOIN pg_class ct ON ct.oid = i.indrelid
@@ -235,10 +231,9 @@ WHERE
     a.attnum = ANY(i.indkey)
     AND con.oid IS NULL
     AND ct.relkind = 'r'
-    AND ct.relname = ?
-ORDER BY index_name, column_position`, string(name))
+    AND ct.relname = ?`, string(name))
 	if err != nil {
-		return nil, provider.sqlstore.WrapNotFoundErrf(err, errors.CodeNotFound, "no indices for table (%s) found", name)
+		return nil, err
 	}
 
 	defer func() {
@@ -247,12 +242,7 @@ ORDER BY index_name, column_position`, string(name))
 		}
 	}()
 
-	type indexEntry struct {
-		columns   []sqlschema.ColumnName
-		predicate *string
-	}
-
-	uniqueIndicesMap := make(map[string]*indexEntry)
+	uniqueIndicesMap := make(map[string]*sqlschema.UniqueIndex)
 	for rows.Next() {
 		var (
 			tableName  string
@@ -260,53 +250,27 @@ ORDER BY index_name, column_position`, string(name))
 			unique     bool
 			primary    bool
 			columnName string
-			// starts from 0 and is unused in this function, this is to ensure that the column names are in the correct order
-			columnPosition int
-			predicate      *string
 		)
 
-		if err := rows.Scan(&tableName, &indexName, &unique, &primary, &columnName, &columnPosition, &predicate); err != nil {
+		if err := rows.Scan(&tableName, &indexName, &unique, &primary, &columnName); err != nil {
 			return nil, err
 		}
 
 		if unique {
 			if _, ok := uniqueIndicesMap[indexName]; !ok {
-				uniqueIndicesMap[indexName] = &indexEntry{
-					columns:   []sqlschema.ColumnName{sqlschema.ColumnName(columnName)},
-					predicate: predicate,
+				uniqueIndicesMap[indexName] = &sqlschema.UniqueIndex{
+					TableName:   name,
+					ColumnNames: []sqlschema.ColumnName{sqlschema.ColumnName(columnName)},
 				}
 			} else {
-				uniqueIndicesMap[indexName].columns = append(uniqueIndicesMap[indexName].columns, sqlschema.ColumnName(columnName))
+				uniqueIndicesMap[indexName].ColumnNames = append(uniqueIndicesMap[indexName].ColumnNames, sqlschema.ColumnName(columnName))
 			}
 		}
 	}
 
 	indices := make([]sqlschema.Index, 0)
-	for indexName, entry := range uniqueIndicesMap {
-		if entry.predicate != nil {
-			index := &sqlschema.PartialUniqueIndex{
-				TableName:   name,
-				ColumnNames: entry.columns,
-				Where:       *entry.predicate,
-			}
-
-			if index.Name() == indexName {
-				indices = append(indices, index)
-			} else {
-				indices = append(indices, index.Named(indexName))
-			}
-		} else {
-			index := &sqlschema.UniqueIndex{
-				TableName:   name,
-				ColumnNames: entry.columns,
-			}
-
-			if index.Name() == indexName {
-				indices = append(indices, index)
-			} else {
-				indices = append(indices, index.Named(indexName))
-			}
-		}
+	for _, index := range uniqueIndicesMap {
+		indices = append(indices, index)
 	}
 
 	return indices, nil

frontend/__mocks__/resizableMock.tsx

@@ -1,29 +0,0 @@
-import { PropsWithChildren } from 'react';
-
-type CommonProps = PropsWithChildren<{
-	className?: string;
-	minSize?: number;
-	maxSize?: number;
-	defaultSize?: number;
-	direction?: 'horizontal' | 'vertical';
-	autoSaveId?: string;
-	withHandle?: boolean;
-}>;
-
-export function ResizablePanelGroup({
-	children,
-	className,
-}: CommonProps): JSX.Element {
-	return <div className={className}>{children}</div>;
-}
-
-export function ResizablePanel({
-	children,
-	className,
-}: CommonProps): JSX.Element {
-	return <div className={className}>{children}</div>;
-}
-
-export function ResizableHandle({ className }: CommonProps): JSX.Element {
-	return <div className={className} />;
-}

frontend/jest.config.ts

@@ -14,7 +14,6 @@ const config: Config.InitialOptions = {
 		'\\.(css|less|scss)$': '<rootDir>/__mocks__/cssMock.ts',
 		'\\.md$': '<rootDir>/__mocks__/cssMock.ts',
 		'^uplot$': '<rootDir>/__mocks__/uplotMock.ts',
-		'^@signozhq/resizable$': '<rootDir>/__mocks__/resizableMock.tsx',
 		'^hooks/useSafeNavigate$': USE_SAFE_NAVIGATE_MOCK_PATH,
 		'^src/hooks/useSafeNavigate$': USE_SAFE_NAVIGATE_MOCK_PATH,
 		'^.*/useSafeNavigate$': USE_SAFE_NAVIGATE_MOCK_PATH,

frontend/package.json

@@ -64,7 +64,7 @@
     "@signozhq/sonner": "0.1.0",
     "@signozhq/switch": "0.0.2",
     "@signozhq/table": "0.3.7",
-    "@signozhq/toggle-group": "0.0.1",
+    "@signozhq/toggle-group": "^0.0.1",
     "@signozhq/tooltip": "0.0.2",
     "@tanstack/react-table": "8.20.6",
     "@tanstack/react-virtual": "3.11.2",

frontend/src/constants/queryBuilder.ts

@@ -1,6 +1,5 @@
 // ** Helpers
 import { MetrictypesTypeDTO } from 'api/generated/services/sigNoz.schemas';
-import { defaultTraceSelectedColumns } from 'container/OptionsMenu/constants';
 import { createIdFromObjectFields } from 'lib/createIdFromObjectFields';
 import { createNewBuilderItemName } from 'lib/newQueryBuilder/createNewBuilderItemName';
 import { IAttributeValuesResponse } from 'types/api/queryBuilder/getAttributesValues';
@@ -549,49 +548,3 @@ export const DATA_TYPE_VS_ATTRIBUTE_VALUES_KEY: Record<
 	[DataTypes.ArrayBool]: 'boolAttributeValues',
 	[DataTypes.EMPTY]: 'stringAttributeValues',
 };
-
-export const listViewInitialLogQuery: Query = {
-	...initialQueriesMap.logs,
-	builder: {
-		...initialQueriesMap.logs.builder,
-		queryData: [
-			{
-				...initialQueriesMap.logs.builder.queryData[0],
-				aggregateOperator: LogsAggregatorOperator.NOOP,
-				orderBy: [{ columnName: 'timestamp', order: 'desc' }],
-				offset: 0,
-				pageSize: 100,
-			},
-		],
-	},
-};
-
-export const PANEL_TYPES_INITIAL_QUERY: Record<PANEL_TYPES, Query> = {
-	[PANEL_TYPES.TIME_SERIES]: initialQueriesMap.metrics,
-	[PANEL_TYPES.VALUE]: initialQueriesMap.metrics,
-	[PANEL_TYPES.TABLE]: initialQueriesMap.metrics,
-	[PANEL_TYPES.LIST]: listViewInitialLogQuery,
-	[PANEL_TYPES.TRACE]: initialQueriesMap.traces,
-	[PANEL_TYPES.BAR]: initialQueriesMap.metrics,
-	[PANEL_TYPES.PIE]: initialQueriesMap.metrics,
-	[PANEL_TYPES.HISTOGRAM]: initialQueriesMap.metrics,
-	[PANEL_TYPES.EMPTY_WIDGET]: initialQueriesMap.metrics,
-};
-
-export const listViewInitialTraceQuery: Query = {
-	// it should be the above commented query
-	...initialQueriesMap.traces,
-	builder: {
-		...initialQueriesMap.traces.builder,
-		queryData: [
-			{
-				...initialQueriesMap.traces.builder.queryData[0],
-				aggregateOperator: LogsAggregatorOperator.NOOP,
-				orderBy: [{ columnName: 'timestamp', order: 'desc' }],
-				offset: 0,
-				pageSize: 10,
-				selectColumns: defaultTraceSelectedColumns,
-			},
-		],
-	},
-};

frontend/src/container/DashboardContainer/ComponentsSlider/ComponentSlider.styles.scss

@@ -1,4 +1,4 @@
-.panel-type-selection-modal {
+.graph-selection {
 	.ant-modal-content {
 		width: 515px;
 		max-height: 646px;
@@ -76,11 +76,6 @@
 						content: none;
 					}
 				}
-
-				.panel-type-text {
-					text-align: center;
-					margin-top: 1rem;
-				}
 			}
 		}
 
@@ -119,7 +114,7 @@
 }
 
 .lightMode {
-	.panel-type-selection-modal {
+	.graph-selection {
 		.ant-modal-content {
 			border: 1px solid var(--bg-vanilla-300);
 			background: var(--bg-vanilla-100);

frontend/src/container/DashboardContainer/ComponentsSlider/constants.ts

@@ -0,0 +1,50 @@
+import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
+import { defaultTraceSelectedColumns } from 'container/OptionsMenu/constants';
+import { Query } from 'types/api/queryBuilder/queryBuilderData';
+import { LogsAggregatorOperator } from 'types/common/queryBuilder';
+
+export const PANEL_TYPES_INITIAL_QUERY = {
+	[PANEL_TYPES.TIME_SERIES]: initialQueriesMap.metrics,
+	[PANEL_TYPES.VALUE]: initialQueriesMap.metrics,
+	[PANEL_TYPES.TABLE]: initialQueriesMap.metrics,
+	[PANEL_TYPES.LIST]: initialQueriesMap.logs,
+	[PANEL_TYPES.TRACE]: initialQueriesMap.traces,
+	[PANEL_TYPES.BAR]: initialQueriesMap.metrics,
+	[PANEL_TYPES.PIE]: initialQueriesMap.metrics,
+	[PANEL_TYPES.HISTOGRAM]: initialQueriesMap.metrics,
+	[PANEL_TYPES.EMPTY_WIDGET]: initialQueriesMap.metrics,
+};
+
+export const listViewInitialLogQuery: Query = {
+	...initialQueriesMap.logs,
+	builder: {
+		...initialQueriesMap.logs.builder,
+		queryData: [
+			{
+				...initialQueriesMap.logs.builder.queryData[0],
+				aggregateOperator: LogsAggregatorOperator.NOOP,
+				orderBy: [{ columnName: 'timestamp', order: 'desc' }],
+				offset: 0,
+				pageSize: 100,
+			},
+		],
+	},
+};
+
+export const listViewInitialTraceQuery: Query = {
+	// it should be the above commented query
+	...initialQueriesMap.traces,
+	builder: {
+		...initialQueriesMap.traces.builder,
+		queryData: [
+			{
+				...initialQueriesMap.traces.builder.queryData[0],
+				aggregateOperator: LogsAggregatorOperator.NOOP,
+				orderBy: [{ columnName: 'timestamp', order: 'desc' }],
+				offset: 0,
+				pageSize: 10,
+				selectColumns: defaultTraceSelectedColumns,
+			},
+		],
+	},
+};

frontend/src/container/DashboardContainer/ComponentsSlider/index.tsx

@@ -0,0 +1,94 @@
+import { Card, Modal } from 'antd';
+import logEvent from 'api/common/logEvent';
+import { QueryParams } from 'constants/query';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import createQueryParams from 'lib/createQueryParams';
+import history from 'lib/history';
+import { useDashboard } from 'providers/Dashboard/Dashboard';
+import { LogsAggregatorOperator } from 'types/common/queryBuilder';
+import { v4 as uuid } from 'uuid';
+
+import { PANEL_TYPES_INITIAL_QUERY } from './constants';
+import menuItems from './menuItems';
+import { Text } from './styles';
+
+import './ComponentSlider.styles.scss';
+
+function DashboardGraphSlider(): JSX.Element {
+	const { handleToggleDashboardSlider, isDashboardSliderOpen } = useDashboard();
+
+	const onClickHandler = (name: PANEL_TYPES) => (): void => {
+		const id = uuid();
+		handleToggleDashboardSlider(false);
+		logEvent('Dashboard Detail: New panel type selected', {
+			// dashboardId: '',
+			// dashboardName: '',
+			// numberOfPanels: 0, // todo - at this point we don't know these attributes
+			panelType: name,
+			widgetId: id,
+		});
+		const queryParamsLog = {
+			graphType: name,
+			widgetId: id,
+			[QueryParams.compositeQuery]: JSON.stringify({
+				...PANEL_TYPES_INITIAL_QUERY[name],
+				builder: {
+					...PANEL_TYPES_INITIAL_QUERY[name].builder,
+					queryData: [
+						{
+							...PANEL_TYPES_INITIAL_QUERY[name].builder.queryData[0],
+							aggregateOperator: LogsAggregatorOperator.NOOP,
+							orderBy: [{ columnName: 'timestamp', order: 'desc' }],
+							offset: 0,
+							pageSize: 100,
+						},
+					],
+				},
+			}),
+		};
+
+		const queryParams = {
+			graphType: name,
+			widgetId: id,
+			[QueryParams.compositeQuery]: JSON.stringify(
+				PANEL_TYPES_INITIAL_QUERY[name],
+			),
+		};
+		if (name === PANEL_TYPES.LIST) {
+			history.push(
+				`${history.location.pathname}/new?${createQueryParams(queryParamsLog)}`,
+			);
+		} else {
+			history.push(
+				`${history.location.pathname}/new?${createQueryParams(queryParams)}`,
+			);
+		}
+	};
+
+	const handleCardClick = (panelType: PANEL_TYPES): void => {
+		onClickHandler(panelType)();
+	};
+
+	return (
+		<Modal
+			open={isDashboardSliderOpen}
+			onCancel={(): void => {
+				handleToggleDashboardSlider(false);
+			}}
+			rootClassName="graph-selection"
+			footer={null}
+			title="New Panel"
+		>
+			<div className="panel-selection">
+				{menuItems.map(({ name, icon, display }) => (
+					<Card onClick={(): void => handleCardClick(name)} id={name} key={name}>
+						{icon}
+						<Text>{display}</Text>
+					</Card>
+				))}
+			</div>
+		</Modal>
+	);
+}
+
+export default DashboardGraphSlider;

frontend/src/container/DashboardContainer/ComponentsSlider/menuItems.tsx

@@ -9,7 +9,7 @@ import {
 	Table,
 } from 'lucide-react';
 
-export const PanelTypesWithData: ItemsProps[] = [
+const Items: ItemsProps[] = [
 	{
 		name: PANEL_TYPES.TIME_SERIES,
 		icon: <LineChart size={16} color={Color.BG_ROBIN_400} />,
@@ -52,3 +52,5 @@ export interface ItemsProps {
 	icon: JSX.Element;
 	display: string;
 }
+
+export default Items;

frontend/src/container/DashboardContainer/ComponentsSlider/styles.ts

@@ -0,0 +1,41 @@
+import { Card as CardComponent, Typography } from 'antd';
+import styled from 'styled-components';
+
+export const Container = styled.div`
+	display: flex;
+	justify-content: right;
+	gap: 8px;
+	margin-bottom: 12px;
+`;
+
+export const Card = styled(CardComponent)`
+	min-height: 80px;
+	min-width: 120px;
+	overflow-y: auto;
+	cursor: pointer;
+	transition: transform 0.2s;
+
+	.ant-card-body {
+		padding: 12px;
+		height: 100%;
+		display: flex;
+		flex-direction: column;
+		justify-content: space-between;
+		align-items: center;
+
+		.ant-typography {
+			font-size: 12px;
+			font-weight: 600;
+		}
+	}
+
+	&:hover {
+		transform: scale(1.05);
+		border: 1px solid var(--bg-robin-400);
+	}
+`;
+
+export const Text = styled(Typography)`
+	text-align: center;
+	margin-top: 1rem;
+`;

frontend/src/container/DashboardContainer/DashboardDescription/__tests__/DashboardDescription.test.tsx

@@ -182,7 +182,9 @@ describe('Dashboard landing page actions header tests', () => {
 		(useLocation as jest.Mock).mockReturnValue(mockLocation);
 
 		const mockContextValue: IDashboardContext = {
+			isDashboardSliderOpen: false,
 			isDashboardLocked: false,
+			handleToggleDashboardSlider: jest.fn(),
 			handleDashboardLockToggle: jest.fn(),
 			dashboardResponse: {} as IDashboardContext['dashboardResponse'],
 			selectedDashboard: (getDashboardById.data as unknown) as Dashboard,

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

@@ -40,7 +40,6 @@ import {
 } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
 import { useDashboard } from 'providers/Dashboard/Dashboard';
-import { usePanelTypeSelectionModalStore } from 'providers/Dashboard/helpers/panelTypeSelectionModalHelper';
 import { sortLayout } from 'providers/Dashboard/util';
 import { DashboardData } from 'types/api/dashboard/getAll';
 import { Props } from 'types/api/dashboard/update';
@@ -49,10 +48,10 @@ import { ComponentTypes } from 'utils/permission';
 import { v4 as uuid } from 'uuid';
 
 import DashboardHeader from '../components/DashboardHeader/DashboardHeader';
+import DashboardGraphSlider from '../ComponentsSlider';
 import DashboardSettings from '../DashboardSettings';
 import { Base64Icons } from '../DashboardSettings/General/utils';
 import DashboardVariableSelection from '../DashboardVariablesSelection';
-import PanelTypeSelectionModal from '../PanelTypeSelectionModal';
 import SettingsDrawer from './SettingsDrawer';
 import { VariablesSettingsTab } from './types';
 import {
@@ -70,9 +69,6 @@ interface DashboardDescriptionProps {
 // eslint-disable-next-line sonarjs/cognitive-complexity
 function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 	const { handle } = props;
-	const setIsPanelTypeSelectionModalOpen = usePanelTypeSelectionModalStore(
-		(s) => s.setIsPanelTypeSelectionModalOpen,
-	);
 	const {
 		selectedDashboard,
 		panelMap,
@@ -81,6 +77,7 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 		setLayouts,
 		isDashboardLocked,
 		setSelectedDashboard,
+		handleToggleDashboardSlider,
 		handleDashboardLockToggle,
 	} = useDashboard();
 
@@ -148,14 +145,14 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 	const [addPanelPermission] = useComponentPermission(permissions, userRole);
 
 	const onEmptyWidgetHandler = useCallback(() => {
-		setIsPanelTypeSelectionModalOpen(true);
+		handleToggleDashboardSlider(true);
 		logEvent('Dashboard Detail: Add new panel clicked', {
 			dashboardId: selectedDashboard?.id,
 			dashboardName: selectedDashboard?.data.title,
 			numberOfPanels: selectedDashboard?.data.widgets?.length,
 		});
 		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [setIsPanelTypeSelectionModalOpen]);
+	}, [handleToggleDashboardSlider]);
 
 	const handleLockDashboardToggle = (): void => {
 		setIsDashbordSettingsOpen(false);
@@ -524,7 +521,7 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 					<DashboardVariableSelection />
 				</section>
 			)}
-			<PanelTypeSelectionModal />
+			<DashboardGraphSlider />
 
 			<Modal
 				open={isRenameDashboardOpen}

frontend/src/container/DashboardContainer/PanelTypeSelectionModal/index.tsx

@@ -1,68 +0,0 @@
-import { memo } from 'react';
-import { Card, Modal, Typography } from 'antd';
-import logEvent from 'api/common/logEvent';
-import { QueryParams } from 'constants/query';
-import { PANEL_TYPES, PANEL_TYPES_INITIAL_QUERY } from 'constants/queryBuilder';
-import createQueryParams from 'lib/createQueryParams';
-import history from 'lib/history';
-import { usePanelTypeSelectionModalStore } from 'providers/Dashboard/helpers/panelTypeSelectionModalHelper';
-import { v4 as uuid } from 'uuid';
-
-import { PanelTypesWithData } from './menuItems';
-
-import './PanelTypeSelectionModal.styles.scss';
-
-function PanelTypeSelectionModal(): JSX.Element {
-	const {
-		isPanelTypeSelectionModalOpen,
-		setIsPanelTypeSelectionModalOpen,
-	} = usePanelTypeSelectionModalStore();
-
-	const onClickHandler = (name: PANEL_TYPES) => (): void => {
-		const id = uuid();
-		setIsPanelTypeSelectionModalOpen(false);
-		logEvent('Dashboard Detail: New panel type selected', {
-			panelType: name,
-			widgetId: id,
-		});
-
-		const queryParams = {
-			graphType: name,
-			widgetId: id,
-			[QueryParams.compositeQuery]: JSON.stringify(
-				PANEL_TYPES_INITIAL_QUERY[name],
-			),
-		};
-
-		history.push(
-			`${history.location.pathname}/new?${createQueryParams(queryParams)}`,
-		);
-	};
-
-	const handleCardClick = (panelType: PANEL_TYPES): void => {
-		onClickHandler(panelType)();
-	};
-
-	return (
-		<Modal
-			open={isPanelTypeSelectionModalOpen}
-			onCancel={(): void => {
-				setIsPanelTypeSelectionModalOpen(false);
-			}}
-			rootClassName="panel-type-selection-modal"
-			footer={null}
-			title="New Panel"
-		>
-			<div className="panel-selection">
-				{PanelTypesWithData.map(({ name, icon, display }) => (
-					<Card onClick={(): void => handleCardClick(name)} id={name} key={name}>
-						{icon}
-						<Typography className="panel-type-text">{display}</Typography>
-					</Card>
-				))}
-			</div>
-		</Modal>
-	);
-}
-
-export default memo(PanelTypeSelectionModal);

frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/__tests__/utils.test.ts

@@ -224,7 +224,7 @@ describe('TimeSeriesPanel utils', () => {
 			});
 		});
 
-		it('uses DrawStyle.Line and showPoints false when series has multiple valid points', () => {
+		it('uses DrawStyle.Line and VisibilityMode.Never when series has multiple valid points', () => {
 			const apiResponse = createApiResponse([
 				{
 					metric: {},

frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/utils.ts

@@ -10,9 +10,9 @@ import getLabelName from 'lib/getLabelName';
 import { OnClickPluginOpts } from 'lib/uPlotLib/plugins/onClickPlugin';
 import {
 	DrawStyle,
-	FillMode,
 	LineInterpolation,
 	LineStyle,
+	VisibilityMode,
 } from 'lib/uPlotV2/config/types';
 import { UPlotConfigBuilder } from 'lib/uPlotV2/config/UPlotConfigBuilder';
 import { isInvalidPlotValue } from 'lib/uPlotV2/utils/dataUtils';
@@ -124,12 +124,12 @@ export const prepareUPlotConfig = ({
 			label: label,
 			colorMapping: widget.customLegendColors ?? {},
 			spanGaps: true,
-			lineStyle: widget.lineStyle || LineStyle.Solid,
-			lineInterpolation: widget.lineInterpolation || LineInterpolation.Spline,
-			showPoints:
-				widget.showPoints || hasSingleValidPoint ? true : !!widget.showPoints,
+			lineStyle: LineStyle.Solid,
+			lineInterpolation: LineInterpolation.Spline,
+			showPoints: hasSingleValidPoint
+				? VisibilityMode.Always
+				: VisibilityMode.Never,
 			pointSize: 5,
-			fillMode: widget.fillMode || FillMode.None,
 			isDarkMode,
 		});
 	});

frontend/src/container/GridCardLayout/DashboardEmptyState/DashboardEmptyState.tsx

@@ -9,18 +9,17 @@ import DashboardSettings from 'container/DashboardContainer/DashboardSettings';
 import useComponentPermission from 'hooks/useComponentPermission';
 import { useAppContext } from 'providers/App/App';
 import { useDashboard } from 'providers/Dashboard/Dashboard';
-import { usePanelTypeSelectionModalStore } from 'providers/Dashboard/helpers/panelTypeSelectionModalHelper';
 import { ROLES, USER_ROLES } from 'types/roles';
 import { ComponentTypes } from 'utils/permission';
 
 import './DashboardEmptyState.styles.scss';
 
 export default function DashboardEmptyState(): JSX.Element {
-	const setIsPanelTypeSelectionModalOpen = usePanelTypeSelectionModalStore(
-		(s) => s.setIsPanelTypeSelectionModalOpen,
-	);
-
-	const { selectedDashboard, isDashboardLocked } = useDashboard();
+	const {
+		selectedDashboard,
+		isDashboardLocked,
+		handleToggleDashboardSlider,
+	} = useDashboard();
 
 	const variablesSettingsTabHandle = useRef<VariablesSettingsTab>(null);
 	const [isSettingsDrawerOpen, setIsSettingsDrawerOpen] = useState<boolean>(
@@ -42,14 +41,14 @@ export default function DashboardEmptyState(): JSX.Element {
 	const [addPanelPermission] = useComponentPermission(permissions, userRole);
 
 	const onEmptyWidgetHandler = useCallback(() => {
-		setIsPanelTypeSelectionModalOpen(true);
+		handleToggleDashboardSlider(true);
 		logEvent('Dashboard Detail: Add new panel clicked', {
 			dashboardId: selectedDashboard?.id,
 			dashboardName: selectedDashboard?.data.title,
 			numberOfPanels: selectedDashboard?.data.widgets?.length,
 		});
 		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [setIsPanelTypeSelectionModalOpen]);
+	}, [handleToggleDashboardSlider]);
 
 	const onConfigureClick = useCallback((): void => {
 		setIsSettingsDrawerOpen(true);

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

@@ -2,7 +2,7 @@ import { useCallback } from 'react';
 import { Select, Typography } from 'antd';
 import { QueryParams } from 'constants/query';
 import { PANEL_TYPES } from 'constants/queryBuilder';
-import { PanelTypesWithData } from 'container/DashboardContainer/PanelTypeSelectionModal/menuItems';
+import GraphTypes from 'container/DashboardContainer/ComponentsSlider/menuItems';
 import { handleQueryChange } from 'container/NewWidget/utils';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
@@ -59,7 +59,7 @@ function PanelTypeSelector({
 				data-testid="panel-change-select"
 				disabled={disabled}
 			>
-				{PanelTypesWithData.map((item) => (
+				{GraphTypes.map((item) => (
 					<Option key={item.name} value={item.name}>
 						<div className="view-panel-select-option">
 							<div className="icon">{item.icon}</div>

frontend/src/container/GridCardLayout/WidgetRow.tsx

@@ -5,7 +5,6 @@ import useComponentPermission from 'hooks/useComponentPermission';
 import { EllipsisIcon, PenLine, Plus, X } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
 import { useDashboard } from 'providers/Dashboard/Dashboard';
-import { usePanelTypeSelectionModalStore } from 'providers/Dashboard/helpers/panelTypeSelectionModalHelper';
 import { setSelectedRowWidgetId } from 'providers/Dashboard/helpers/selectedRowWidgetIdHelper';
 import { ROLES, USER_ROLES } from 'types/roles';
 import { ComponentTypes } from 'utils/permission';
@@ -35,11 +34,11 @@ export function WidgetRowHeader(props: WidgetRowHeaderProps): JSX.Element {
 	} = props;
 	const [isRowSettingsOpen, setIsRowSettingsOpen] = useState<boolean>(false);
 
-	const setIsPanelTypeSelectionModalOpen = usePanelTypeSelectionModalStore(
-		(s) => s.setIsPanelTypeSelectionModalOpen,
-	);
-
-	const { selectedDashboard, isDashboardLocked } = useDashboard();
+	const {
+		handleToggleDashboardSlider,
+		selectedDashboard,
+		isDashboardLocked,
+	} = useDashboard();
 
 	const permissions: ComponentTypes[] = ['add_panel'];
 	const { user } = useAppContext();
@@ -88,7 +87,7 @@ export function WidgetRowHeader(props: WidgetRowHeaderProps): JSX.Element {
 								}
 
 								setSelectedRowWidgetId(selectedDashboard.id, id);
-								setIsPanelTypeSelectionModalOpen(true);
+								handleToggleDashboardSlider(true);
 							}}
 						>
 							New Panel

frontend/src/container/Home/Home.tsx

@@ -15,7 +15,6 @@ import ROUTES from 'constants/routes';
 import { getMetricsListQuery } from 'container/MetricsExplorer/Summary/utils';
 import { useGetMetricsList } from 'hooks/metricsExplorer/useGetMetricsList';
 import { useGetQueryRange } from 'hooks/queryBuilder/useGetQueryRange';
-import { useIsDarkMode } from 'hooks/useDarkMode';
 import history from 'lib/history';
 import cloneDeep from 'lodash-es/cloneDeep';
 import { AnimatePresence } from 'motion/react';
@@ -44,7 +43,6 @@ const homeInterval = 30 * 60 * 1000;
 // eslint-disable-next-line sonarjs/cognitive-complexity
 export default function Home(): JSX.Element {
 	const { user } = useAppContext();
-	const isDarkMode = useIsDarkMode();
 
 	const [startTime, setStartTime] = useState<number | null>(null);
 	const [endTime, setEndTime] = useState<number | null>(null);
@@ -682,11 +680,7 @@ export default function Home(): JSX.Element {
 
 												<div className="checklist-img-container">
 													<img
-														src={
-															isDarkMode
-																? '/Images/allInOne.svg'
-																: '/Images/allInOneLightMode.svg'
-														}
+														src="/Images/allInOne.svg"
 														alt="checklist-img"
 														className="checklist-img"
 													/>

frontend/src/container/NewWidget/NewWidget.styles.scss

@@ -65,35 +65,6 @@
 	}
 }
 
-.new-widget-container {
-	.resizable-panel-left-container {
-		overflow-x: hidden;
-		overflow-y: auto;
-	}
-
-	.resizable-panel-right-container {
-		overflow-y: auto !important;
-		min-width: 350px;
-
-		&::-webkit-scrollbar {
-			width: 0.3rem;
-		}
-		&::-webkit-scrollbar-thumb {
-			background: rgb(136, 136, 136);
-			border-radius: 0.625rem;
-		}
-		&::-webkit-scrollbar-track {
-			background: transparent;
-		}
-	}
-
-	.widget-resizable-panel-group {
-		.widget-resizable-handle {
-			height: 100vh;
-		}
-	}
-}
-
 .lightMode {
 	.edit-header {
 		border-bottom: 1px solid var(--bg-vanilla-300);
@@ -110,11 +81,4 @@
 			}
 		}
 	}
-
-	.widget-resizable-panel-group {
-		.bg-border {
-			background: var(--bg-vanilla-300);
-			border-color: var(--bg-vanilla-300);
-		}
-	}
 }

frontend/src/container/NewWidget/RightContainer/FillModeSelector.styles.scss

@@ -1,21 +0,0 @@
-.fill-mode-selector {
-	.fill-mode-icon {
-		width: 24px;
-		height: 24px;
-	}
-
-	.fill-mode-label {
-		text-transform: uppercase;
-		font-size: 12px;
-		font-weight: 500;
-		color: var(--bg-vanilla-400);
-	}
-}
-
-.lightMode {
-	.fill-mode-selector {
-		.fill-mode-label {
-			color: var(--bg-ink-400);
-		}
-	}
-}

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

@@ -1,94 +0,0 @@
-import { ToggleGroup, ToggleGroupItem } from '@signozhq/toggle-group';
-import { Typography } from 'antd';
-import { FillMode } from 'lib/uPlotV2/config/types';
-
-import './FillModeSelector.styles.scss';
-
-interface FillModeSelectorProps {
-	value: FillMode;
-	onChange: (value: FillMode) => void;
-}
-
-export function FillModeSelector({
-	value,
-	onChange,
-}: FillModeSelectorProps): JSX.Element {
-	return (
-		<section className="fill-mode-selector control-container">
-			<Typography.Text className="section-heading">Fill mode</Typography.Text>
-			<ToggleGroup
-				type="single"
-				value={value}
-				variant="outline"
-				size="lg"
-				onValueChange={(newValue): void => {
-					if (newValue) {
-						onChange(newValue as FillMode);
-					}
-				}}
-			>
-				<ToggleGroupItem value={FillMode.None} aria-label="None" title="None">
-					<svg
-						className="fill-mode-icon"
-						viewBox="0 0 48 48"
-						fill="none"
-						stroke="#888"
-						strokeWidth="2"
-						strokeLinecap="round"
-						strokeLinejoin="round"
-					>
-						<rect x="8" y="16" width="32" height="16" stroke="#888" fill="none" />
-					</svg>
-					<Typography.Text className="section-heading-small">None</Typography.Text>
-				</ToggleGroupItem>
-				<ToggleGroupItem value={FillMode.Solid} aria-label="Solid" title="Solid">
-					<svg
-						className="fill-mode-icon"
-						viewBox="0 0 48 48"
-						fill="none"
-						stroke="#888"
-						strokeWidth="2"
-						strokeLinecap="round"
-						strokeLinejoin="round"
-					>
-						<rect x="8" y="16" width="32" height="16" fill="#888" />
-					</svg>
-					<Typography.Text className="section-heading-small">Solid</Typography.Text>
-				</ToggleGroupItem>
-				<ToggleGroupItem
-					value={FillMode.Gradient}
-					aria-label="Gradient"
-					title="Gradient"
-				>
-					<svg
-						className="fill-mode-icon"
-						viewBox="0 0 48 48"
-						fill="none"
-						stroke="#888"
-						strokeWidth="2"
-						strokeLinecap="round"
-						strokeLinejoin="round"
-					>
-						<defs>
-							<linearGradient id="fill-gradient" x1="0" y1="0" x2="1" y2="0">
-								<stop offset="0%" stopColor="#888" stopOpacity="0.2" />
-								<stop offset="100%" stopColor="#888" stopOpacity="0.8" />
-							</linearGradient>
-						</defs>
-						<rect
-							x="8"
-							y="16"
-							width="32"
-							height="16"
-							fill="url(#fill-gradient)"
-							stroke="#888"
-						/>
-					</svg>
-					<Typography.Text className="section-heading-small">
-						Gradient
-					</Typography.Text>
-				</ToggleGroupItem>
-			</ToggleGroup>
-		</section>
-	);
-}

frontend/src/container/NewWidget/RightContainer/LineInterpolationSelector.styles.scss

@@ -1,21 +0,0 @@
-.line-interpolation-selector {
-	.line-interpolation-icon {
-		width: 24px;
-		height: 24px;
-	}
-
-	.line-interpolation-label {
-		text-transform: uppercase;
-		font-size: 12px;
-		font-weight: 500;
-		color: var(--bg-vanilla-400);
-	}
-}
-
-.lightMode {
-	.line-interpolation-selector {
-		.line-interpolation-label {
-			color: var(--bg-ink-400);
-		}
-	}
-}

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

@@ -1,110 +0,0 @@
-import { ToggleGroup, ToggleGroupItem } from '@signozhq/toggle-group';
-import { Typography } from 'antd';
-import { LineInterpolation } from 'lib/uPlotV2/config/types';
-
-import './LineInterpolationSelector.styles.scss';
-
-interface LineInterpolationSelectorProps {
-	value: LineInterpolation;
-	onChange: (value: LineInterpolation) => void;
-}
-
-export function LineInterpolationSelector({
-	value,
-	onChange,
-}: LineInterpolationSelectorProps): JSX.Element {
-	return (
-		<section className="line-interpolation-selector control-container">
-			<Typography.Text className="section-heading">
-				Line interpolation
-			</Typography.Text>
-			<ToggleGroup
-				type="single"
-				value={value}
-				variant="outline"
-				size="lg"
-				onValueChange={(newValue): void => {
-					if (newValue) {
-						onChange(newValue as LineInterpolation);
-					}
-				}}
-			>
-				<ToggleGroupItem
-					value={LineInterpolation.Linear}
-					aria-label="Linear"
-					title="Linear"
-				>
-					<svg
-						className="line-interpolation-icon"
-						viewBox="0 0 48 48"
-						fill="none"
-						stroke="#888"
-						strokeWidth="2"
-						strokeLinecap="round"
-						strokeLinejoin="round"
-					>
-						<circle cx="8" cy="32" r="3" fill="#888" />
-						<circle cx="24" cy="16" r="3" fill="#888" />
-						<circle cx="40" cy="32" r="3" fill="#888" />
-						<path d="M8 32 L24 16 L40 32" stroke="#888" />
-					</svg>
-				</ToggleGroupItem>
-				<ToggleGroupItem value={LineInterpolation.Spline} aria-label="Spline">
-					<svg
-						className="line-interpolation-icon"
-						viewBox="0 0 48 48"
-						fill="none"
-						stroke="#888"
-						strokeWidth="2"
-						strokeLinecap="round"
-						strokeLinejoin="round"
-					>
-						<circle cx="8" cy="32" r="3" fill="#888" />
-						<circle cx="24" cy="16" r="3" fill="#888" />
-						<circle cx="40" cy="32" r="3" fill="#888" />
-						<path d="M8 32 C16 8, 32 8, 40 32" />
-					</svg>
-				</ToggleGroupItem>
-				<ToggleGroupItem
-					value={LineInterpolation.StepAfter}
-					aria-label="Step After"
-				>
-					<svg
-						className="line-interpolation-icon"
-						viewBox="0 0 48 48"
-						fill="none"
-						stroke="#888"
-						strokeWidth="2"
-						strokeLinecap="round"
-						strokeLinejoin="round"
-					>
-						<circle cx="8" cy="32" r="3" fill="#888" />
-						<circle cx="24" cy="16" r="3" fill="#888" />
-						<circle cx="40" cy="32" r="3" fill="#888" />
-						<path d="M8 32 V16 H24 V32 H40" />
-					</svg>
-				</ToggleGroupItem>
-
-				<ToggleGroupItem
-					value={LineInterpolation.StepBefore}
-					aria-label="Step Before"
-				>
-					<svg
-						className="line-interpolation-icon"
-						viewBox="0 0 48 48"
-						fill="none"
-						stroke="#888"
-						strokeWidth="2"
-						strokeLinecap="round"
-						strokeLinejoin="round"
-					>
-						<circle cx="8" cy="32" r="3" fill="#888" />
-						<circle cx="24" cy="16" r="3" fill="#888" />
-						<circle cx="40" cy="32" r="3" fill="#888" />
-						<path d="M8 32 H24 V16 H40 V32" />
-					</svg>
-				</ToggleGroupItem>
-			</ToggleGroup>
-		</section>
-	);
-}

frontend/src/container/NewWidget/RightContainer/LineStyleSelector.styles.scss

@@ -1,21 +0,0 @@
-.line-style-selector {
-	.line-style-icon {
-		width: 24px;
-		height: 24px;
-	}
-
-	.line-style-label {
-		text-transform: uppercase;
-		font-size: 12px;
-		font-weight: 500;
-		color: var(--bg-vanilla-400);
-	}
-}
-
-.lightMode {
-	.line-style-selector {
-		.line-style-label {
-			color: var(--bg-ink-400);
-		}
-	}
-}

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

@@ -1,66 +0,0 @@
-import { ToggleGroup, ToggleGroupItem } from '@signozhq/toggle-group';
-import { Typography } from 'antd';
-import { LineStyle } from 'lib/uPlotV2/config/types';
-
-import './LineStyleSelector.styles.scss';
-
-interface LineStyleSelectorProps {
-	value: LineStyle;
-	onChange: (value: LineStyle) => void;
-}
-
-export function LineStyleSelector({
-	value,
-	onChange,
-}: LineStyleSelectorProps): JSX.Element {
-	return (
-		<section className="line-style-selector control-container">
-			<Typography.Text className="section-heading">Line style</Typography.Text>
-			<ToggleGroup
-				type="single"
-				value={value}
-				variant="outline"
-				size="lg"
-				onValueChange={(newValue): void => {
-					if (newValue) {
-						onChange(newValue as LineStyle);
-					}
-				}}
-			>
-				<ToggleGroupItem value={LineStyle.Solid} aria-label="Solid" title="Solid">
-					<svg
-						className="line-style-icon"
-						viewBox="0 0 48 48"
-						fill="none"
-						stroke="#888"
-						strokeWidth="2"
-						strokeLinecap="round"
-						strokeLinejoin="round"
-					>
-						<path d="M8 24 L40 24" />
-					</svg>
-					<Typography.Text className="section-heading-small">Solid</Typography.Text>
-				</ToggleGroupItem>
-				<ToggleGroupItem
-					value={LineStyle.Dashed}
-					aria-label="Dashed"
-					title="Dashed"
-				>
-					<svg
-						className="line-style-icon"
-						viewBox="0 0 48 48"
-						fill="none"
-						stroke="#888"
-						strokeWidth="2"
-						strokeLinecap="round"
-						strokeLinejoin="round"
-						strokeDasharray="6 4"
-					>
-						<path d="M8 24 L40 24" />
-					</svg>
-					<Typography.Text className="section-heading-small">Dashed</Typography.Text>
-				</ToggleGroupItem>
-			</ToggleGroup>
-		</section>
-	);
-}

frontend/src/container/NewWidget/RightContainer/RightContainer.styles.scss

@@ -1,29 +1,6 @@
 .right-container {
 	display: flex;
 	flex-direction: column;
-	font-family: 'Space Mono';
-	padding-bottom: 48px;
-
-	.section-heading {
-		color: var(--bg-vanilla-400);
-		font-size: 13px;
-		font-style: normal;
-		font-weight: 400;
-		line-height: 18px; /* 138.462% */
-		letter-spacing: 0.52px;
-		text-transform: uppercase;
-	}
-
-	.section-heading-small {
-		font-family: 'Space Mono';
-		color: var(--bg-vanilla-400);
-		font-size: 12px;
-		font-style: normal;
-		font-weight: 400;
-		word-break: initial;
-		line-height: 16px; /* 133.333% */
-		letter-spacing: 0.48px;
-	}
 
 	.header {
 		display: flex;
@@ -56,6 +33,17 @@
 	.name-description {
 		padding: 0 0 4px 0;
 
+		.typography {
+			color: var(--bg-vanilla-400);
+			font-family: 'Space Mono';
+			font-size: 13px;
+			font-style: normal;
+			font-weight: 400;
+			line-height: 18px; /* 138.462% */
+			letter-spacing: 0.52px;
+			text-transform: uppercase;
+		}
+
 		.name-input {
 			display: flex;
 			padding: 6px 6px 6px 8px;
@@ -101,21 +89,15 @@
 		display: flex;
 		flex-direction: column;
 
-		.toggle-card {
-			display: flex;
-			flex-direction: row;
-			justify-content: space-between;
-			align-items: center;
-			padding: 12px;
-			border-radius: 2px;
-			border: 1px solid var(--bg-slate-400);
-			background: var(--bg-ink-400);
-		}
-
-		.toggle-card-text-container {
-			display: flex;
-			flex-direction: column;
-			gap: 4px;
+		.typography {
+			color: var(--bg-vanilla-400);
+			font-family: 'Space Mono';
+			font-size: 13px;
+			font-style: normal;
+			font-weight: 400;
+			line-height: 18px; /* 138.462% */
+			letter-spacing: 0.52px;
+			text-transform: uppercase;
 		}
 
 		.panel-type-select {
@@ -131,16 +113,55 @@
 				border: 1px solid var(--bg-slate-400);
 				background: var(--bg-ink-300);
 			}
+
+			.select-option {
+				display: flex;
+				align-items: center;
+				gap: 6px;
+				.icon {
+					display: flex;
+					align-items: center;
+				}
+
+				.display {
+					color: var(--bg-vanilla-100);
+					font-family: Inter;
+					font-size: 12px;
+					font-style: normal;
+					font-weight: 400;
+					line-height: 16px; /* 133.333% */
+				}
+			}
 		}
 
-		.toggle-card-description {
-			color: var(--bg-vanilla-400);
-			font-family: Inter;
-			font-size: 12px;
-			font-style: normal;
-			font-weight: 400;
-			opacity: 0.6;
-			line-height: 16px; /* 133.333% */
+		.fill-gaps {
+			display: flex;
+			padding: 12px;
+			justify-content: space-between;
+			align-items: center;
+			border-radius: 2px;
+			border: 1px solid var(--bg-slate-400);
+			background: var(--bg-ink-400);
+
+			.fill-gaps-text {
+				color: var(--bg-vanilla-400);
+				font-family: 'Space Mono';
+				font-size: 13px;
+				font-style: normal;
+				font-weight: 400;
+				line-height: 18px; /* 138.462% */
+				letter-spacing: 0.52px;
+				text-transform: uppercase;
+			}
+			.fill-gaps-text-description {
+				color: var(--bg-vanilla-400);
+				font-family: Inter;
+				font-size: 12px;
+				font-style: normal;
+				font-weight: 400;
+				opacity: 0.6;
+				line-height: 16px; /* 133.333% */
+			}
 		}
 
 		.log-scale,
@@ -149,6 +170,17 @@
 			justify-content: space-between;
 		}
 
+		.panel-time-text {
+			color: var(--bg-vanilla-400);
+			font-family: 'Space Mono';
+			font-size: 13px;
+			font-style: normal;
+			font-weight: 400;
+			line-height: 18px; /* 138.462% */
+			letter-spacing: 0.52px;
+			text-transform: uppercase;
+		}
+
 		.y-axis-unit-selector,
 		.y-axis-unit-selector-v2 {
 			display: flex;
@@ -156,7 +188,14 @@
 			gap: 8px;
 
 			.heading {
-				@extend .section-heading;
+				color: var(--bg-vanilla-400);
+				font-family: 'Space Mono';
+				font-size: 13px;
+				font-style: normal;
+				font-weight: 400;
+				line-height: 18px; /* 138.462% */
+				letter-spacing: 0.52px;
+				text-transform: uppercase;
 			}
 
 			.input {
@@ -209,6 +248,7 @@
 
 				.text {
 					color: var(--bg-vanilla-400);
+					font-family: 'Space Mono';
 					font-size: 12px;
 					font-style: normal;
 					font-weight: 400;
@@ -229,9 +269,30 @@
 		.stack-chart {
 			flex-direction: row;
 			justify-content: space-between;
+			.label {
+				color: var(--bg-vanilla-400);
+				font-family: 'Space Mono';
+				font-size: 13px;
+				font-style: normal;
+				font-weight: 400;
+				line-height: 18px; /* 138.462% */
+				letter-spacing: 0.52px;
+				text-transform: uppercase;
+			}
 		}
 
 		.bucket-config {
+			.label {
+				color: var(--bg-vanilla-400);
+				font-family: 'Space Mono';
+				font-size: 13px;
+				font-style: normal;
+				font-weight: 400;
+				line-height: 18px; /* 138.462% */
+				letter-spacing: 0.52px;
+				text-transform: uppercase;
+			}
+
 			.bucket-size-label {
 				margin-top: 8px;
 			}
@@ -260,6 +321,7 @@
 
 				.label {
 					color: var(--bg-vanilla-400);
+					font-family: 'Space Mono';
 					font-size: 13px;
 					font-style: normal;
 					font-weight: 400;
@@ -291,6 +353,7 @@
 
 			.alerts-text {
 				color: var(--bg-vanilla-400);
+				font-family: Inter;
 				font-size: 14px;
 				font-style: normal;
 				font-weight: 400;
@@ -336,9 +399,6 @@
 .lightMode {
 	.right-container {
 		background-color: var(--bg-vanilla-100);
-		.section-heading {
-			color: var(--bg-ink-400);
-		}
 		.header {
 			.header-text {
 				color: var(--bg-ink-400);
@@ -366,6 +426,10 @@
 		}
 
 		.panel-config {
+			.typography {
+				color: var(--bg-ink-400);
+			}
+
 			.panel-type-select {
 				.ant-select-selector {
 					border: 1px solid var(--bg-vanilla-300);
@@ -390,14 +454,14 @@
 				}
 			}
 
-			.toggle-card {
+			.fill-gaps {
 				border: 1px solid var(--bg-vanilla-300);
 				background: var(--bg-vanilla-300);
 
 				.fill-gaps-text {
 					color: var(--bg-ink-400);
 				}
-				.toggle-card-description {
+				.fill-gaps-text-description {
 					color: var(--bg-ink-400);
 				}
 			}

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

@@ -6,11 +6,6 @@ import { MemoryRouter } from 'react-router-dom';
 import { render as rtlRender, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { PANEL_TYPES } from 'constants/queryBuilder';
-import {
-	FillMode,
-	LineInterpolation,
-	LineStyle,
-} from 'lib/uPlotV2/config/types';
 import { AppContext } from 'providers/App/App';
 import { IAppContext } from 'providers/App/types';
 import { ErrorModalProvider } from 'providers/ErrorModalProvider';
@@ -170,14 +165,6 @@ describe('RightContainer - Alerts Section', () => {
 		setContextLinks: jest.fn(),
 		enableDrillDown: false,
 		isNewDashboard: false,
-		lineInterpolation: LineInterpolation.Spline,
-		fillMode: FillMode.None,
-		lineStyle: LineStyle.Solid,
-		setLineInterpolation: jest.fn(),
-		setFillMode: jest.fn(),
-		setLineStyle: jest.fn(),
-		showPoints: false,
-		setShowPoints: jest.fn(),
 	};
 
 	beforeEach(() => {

frontend/src/container/NewWidget/RightContainer/components/SettingsSection/SettingsSection.styles.scss

@@ -43,7 +43,7 @@
 	max-height: 0;
 	overflow: hidden;
 	opacity: 0;
-	transition: max-height 0.1s ease, opacity 0.1s ease, padding 0.1s ease;
+	transition: max-height 0.25s ease, opacity 0.25s ease, padding 0.25s ease;
 
 	&.open {
 		padding-bottom: 24px;

frontend/src/container/NewWidget/RightContainer/constants.ts

@@ -206,59 +206,3 @@ export const panelTypeVsDecimalPrecision: {
 	[PANEL_TYPES.TRACE]: false,
 	[PANEL_TYPES.EMPTY_WIDGET]: false,
 } as const;
-
-export const panelTypeVsLineInterpolation: {
-	[key in PANEL_TYPES]: boolean;
-} = {
-	[PANEL_TYPES.TIME_SERIES]: true,
-	[PANEL_TYPES.VALUE]: false,
-	[PANEL_TYPES.TABLE]: false,
-	[PANEL_TYPES.LIST]: false,
-	[PANEL_TYPES.PIE]: false,
-	[PANEL_TYPES.BAR]: false,
-	[PANEL_TYPES.HISTOGRAM]: false,
-	[PANEL_TYPES.TRACE]: false,
-	[PANEL_TYPES.EMPTY_WIDGET]: false,
-} as const;
-
-export const panelTypeVsLineStyle: {
-	[key in PANEL_TYPES]: boolean;
-} = {
-	[PANEL_TYPES.TIME_SERIES]: true,
-	[PANEL_TYPES.VALUE]: false,
-	[PANEL_TYPES.TABLE]: false,
-	[PANEL_TYPES.LIST]: false,
-	[PANEL_TYPES.PIE]: false,
-	[PANEL_TYPES.BAR]: false,
-	[PANEL_TYPES.HISTOGRAM]: false,
-	[PANEL_TYPES.TRACE]: false,
-	[PANEL_TYPES.EMPTY_WIDGET]: false,
-} as const;
-
-export const panelTypeVsFillMode: {
-	[key in PANEL_TYPES]: boolean;
-} = {
-	[PANEL_TYPES.TIME_SERIES]: true,
-	[PANEL_TYPES.VALUE]: false,
-	[PANEL_TYPES.TABLE]: false,
-	[PANEL_TYPES.LIST]: false,
-	[PANEL_TYPES.PIE]: false,
-	[PANEL_TYPES.BAR]: false,
-	[PANEL_TYPES.HISTOGRAM]: false,
-	[PANEL_TYPES.TRACE]: false,
-	[PANEL_TYPES.EMPTY_WIDGET]: false,
-} as const;
-
-export const panelTypeVsShowPoints: {
-	[key in PANEL_TYPES]: boolean;
-} = {
-	[PANEL_TYPES.TIME_SERIES]: true,
-	[PANEL_TYPES.VALUE]: false,
-	[PANEL_TYPES.TABLE]: false,
-	[PANEL_TYPES.LIST]: false,
-	[PANEL_TYPES.PIE]: false,
-	[PANEL_TYPES.BAR]: false,
-	[PANEL_TYPES.HISTOGRAM]: false,
-	[PANEL_TYPES.TRACE]: false,
-	[PANEL_TYPES.EMPTY_WIDGET]: false,
-} as const;

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

@@ -20,18 +20,12 @@ import {
 import { PrecisionOption, PrecisionOptionsEnum } from 'components/Graph/types';
 import TimePreference from 'components/TimePreferenceDropDown';
 import { PANEL_TYPES, PanelDisplay } from 'constants/queryBuilder';
-import {
+import GraphTypes, {
 	ItemsProps,
-	PanelTypesWithData,
-} from 'container/DashboardContainer/PanelTypeSelectionModal/menuItems';
+} from 'container/DashboardContainer/ComponentsSlider/menuItems';
 import { useDashboardVariables } from 'hooks/dashboard/useDashboardVariables';
 import useCreateAlerts from 'hooks/queryBuilder/useCreateAlerts';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import {
-	FillMode,
-	LineInterpolation,
-	LineStyle,
-} from 'lib/uPlotV2/config/types';
 import {
 	Antenna,
 	Axis3D,
@@ -40,7 +34,6 @@ import {
 	LayoutDashboard,
 	LineChart,
 	Link,
-	Paintbrush,
 	Pencil,
 	Plus,
 	SlidersHorizontal,
@@ -66,15 +59,11 @@ import {
 	panelTypeVsContextLinks,
 	panelTypeVsCreateAlert,
 	panelTypeVsDecimalPrecision,
-	panelTypeVsFillMode,
 	panelTypeVsFillSpan,
 	panelTypeVsLegendColors,
 	panelTypeVsLegendPosition,
-	panelTypeVsLineInterpolation,
-	panelTypeVsLineStyle,
 	panelTypeVsLogScale,
 	panelTypeVsPanelTimePreferences,
-	panelTypeVsShowPoints,
 	panelTypeVsSoftMinMax,
 	panelTypeVsStackingChartPreferences,
 	panelTypeVsThreshold,
@@ -82,10 +71,7 @@ import {
 } from './constants';
 import ContextLinks from './ContextLinks';
 import DashboardYAxisUnitSelectorWrapper from './DashboardYAxisUnitSelectorWrapper';
-import { FillModeSelector } from './FillModeSelector';
 import LegendColors from './LegendColors/LegendColors';
-import { LineInterpolationSelector } from './LineInterpolationSelector';
-import { LineStyleSelector } from './LineStyleSelector';
 import ThresholdSelector from './Threshold/ThresholdSelector';
 import { ThresholdProps } from './Threshold/types';
 import { timePreferance } from './timeItems';
@@ -112,14 +98,6 @@ function RightContainer({
 	setTitle,
 	title,
 	selectedGraph,
-	lineInterpolation,
-	setLineInterpolation,
-	fillMode,
-	setFillMode,
-	lineStyle,
-	setLineStyle,
-	showPoints,
-	setShowPoints,
 	bucketCount,
 	bucketWidth,
 	stackedBarChart,
@@ -172,7 +150,7 @@ function RightContainer({
 	);
 
 	const selectedGraphType =
-		PanelTypesWithData.find((e) => e.name === selectedGraph)?.display || '';
+		GraphTypes.find((e) => e.name === selectedGraph)?.display || '';
 
 	const onCreateAlertsHandler = useCreateAlerts(selectedWidget, 'panelView');
 
@@ -196,14 +174,9 @@ function RightContainer({
 		panelTypeVsContextLinks[selectedGraph] && enableDrillDown;
 	const allowDecimalPrecision = panelTypeVsDecimalPrecision[selectedGraph];
 
-	const allowLineInterpolation = panelTypeVsLineInterpolation[selectedGraph];
-	const allowLineStyle = panelTypeVsLineStyle[selectedGraph];
-	const allowFillMode = panelTypeVsFillMode[selectedGraph];
-	const allowShowPoints = panelTypeVsShowPoints[selectedGraph];
-
 	const { currentQuery } = useQueryBuilder();
 
-	const [graphTypes, setGraphTypes] = useState<ItemsProps[]>(PanelTypesWithData);
+	const [graphTypes, setGraphTypes] = useState<ItemsProps[]>(GraphTypes);
 
 	const dashboardVariableOptions = useMemo<VariableOption[]>(() => {
 		return Object.entries(dashboardVariables).map(([, value]) => ({
@@ -227,22 +200,6 @@ function RightContainer({
 		[allowLegendPosition, allowLegendColors],
 	);
 
-	const isChartAppearanceSectionVisible = useMemo(
-		() =>
-			/**
-			 * Disabled for now as we are not done with other settings in chart appearance section
-			 * TODO: @ahrefabhi Enable this after we are done other settings in chart appearance section
-			 */
-
-			// eslint-disable-next-line sonarjs/no-redundant-boolean
-			false &&
-			(allowFillMode ||
-				allowLineStyle ||
-				allowLineInterpolation ||
-				allowShowPoints),
-		[allowFillMode, allowLineStyle, allowLineInterpolation, allowShowPoints],
-	);
-
 	const updateCursorAndDropdown = (value: string, pos: number): void => {
 		setCursorPos(pos);
 		const lastDollar = value.lastIndexOf('$', pos - 1);
@@ -315,7 +272,7 @@ function RightContainer({
 				prev.filter((graph) => graph.name !== PANEL_TYPES.LIST),
 			);
 		} else {
-			setGraphTypes(PanelTypesWithData);
+			setGraphTypes(GraphTypes);
 		}
 	}, [currentQuery]);
 
@@ -342,7 +299,7 @@ function RightContainer({
 
 			<SettingsSection title="General" defaultOpen icon={<Pencil size={14} />}>
 				<section className="name-description control-container">
-					<Typography.Text className="section-heading">Name</Typography.Text>
+					<Typography.Text className="typography">Name</Typography.Text>
 					<AutoComplete
 						options={dashboardVariableOptions}
 						value={inputValue}
@@ -362,7 +319,7 @@ function RightContainer({
 							onBlur={(): void => setAutoCompleteOpen(false)}
 						/>
 					</AutoComplete>
-					<Typography.Text className="section-heading">Description</Typography.Text>
+					<Typography.Text className="typography">Description</Typography.Text>
 					<TextArea
 						placeholder="Enter the panel description here..."
 						bordered
@@ -383,7 +340,7 @@ function RightContainer({
 					icon={<LayoutDashboard size={14} />}
 				>
 					<section className="panel-type control-container">
-						<Typography.Text className="section-heading">Panel Type</Typography.Text>
+						<Typography.Text className="typography">Panel Type</Typography.Text>
 						<Select
 							onChange={setGraphHandler}
 							value={selectedGraph}
@@ -404,7 +361,7 @@ function RightContainer({
 
 					{allowPanelTimePreference && (
 						<section className="panel-time-preference control-container">
-							<Typography.Text className="section-heading">
+							<Typography.Text className="panel-time-text">
 								Panel Time Preference
 							</Typography.Text>
 							<TimePreference
@@ -418,9 +375,7 @@ function RightContainer({
 
 					{allowStackingBarChart && (
 						<section className="stack-chart control-container">
-							<Typography.Text className="section-heading">
-								Stack series
-							</Typography.Text>
+							<Typography.Text className="label">Stack series</Typography.Text>
 							<Switch
 								checked={stackedBarChart}
 								size="small"
@@ -430,10 +385,10 @@ function RightContainer({
 					)}
 
 					{allowFillSpans && (
-						<section className="fill-gaps toggle-card">
-							<div className="toggle-card-text-container">
-								<Typography className="section-heading">Fill gaps</Typography>
-								<Typography.Text className="toggle-card-description">
+						<section className="fill-gaps">
+							<div className="fill-gaps-text-container">
+								<Typography className="fill-gaps-text">Fill gaps</Typography>
+								<Typography.Text className="fill-gaps-text-description">
 									Fill gaps in data with 0 for continuity
 								</Typography.Text>
 							</div>
@@ -492,36 +447,6 @@ function RightContainer({
 					</SettingsSection>
 				)}
 
-				{isChartAppearanceSectionVisible && (
-					<SettingsSection title="Chart Appearance" icon={<Paintbrush size={14} />}>
-						{allowFillMode && (
-							<FillModeSelector value={fillMode} onChange={setFillMode} />
-						)}
-						{allowLineStyle && (
-							<LineStyleSelector value={lineStyle} onChange={setLineStyle} />
-						)}
-						{allowLineInterpolation && (
-							<LineInterpolationSelector
-								value={lineInterpolation}
-								onChange={setLineInterpolation}
-							/>
-						)}
-						{allowShowPoints && (
-							<section className="show-points toggle-card">
-								<div className="toggle-card-text-container">
-									<Typography.Text className="section-heading">
-										Show points
-									</Typography.Text>
-									<Typography.Text className="toggle-card-description">
-										Display individual data points on the chart
-									</Typography.Text>
-								</div>
-								<Switch size="small" checked={showPoints} onChange={setShowPoints} />
-							</section>
-						)}
-					</SettingsSection>
-				)}
-
 				{isAxisSectionVisible && (
 					<SettingsSection title="Axes" icon={<Axis3D size={14} />}>
 						{allowSoftMinMax && (
@@ -549,9 +474,7 @@ function RightContainer({
 
 						{allowLogScale && (
 							<section className="log-scale control-container">
-								<Typography.Text className="section-heading">
-									Y Axis Scale
-								</Typography.Text>
+								<Typography.Text className="typography">Y Axis Scale</Typography.Text>
 								<Select
 									onChange={(value): void =>
 										setIsLogScale(value === LogScale.LOGARITHMIC)
@@ -587,7 +510,7 @@ function RightContainer({
 					<SettingsSection title="Legend" icon={<Layers size={14} />}>
 						{allowLegendPosition && (
 							<section className="legend-position control-container">
-								<Typography.Text className="section-heading">Position</Typography.Text>
+								<Typography.Text className="typography">Position</Typography.Text>
 								<Select
 									onChange={(value: LegendPosition): void => setLegendPosition(value)}
 									value={legendPosition}
@@ -624,9 +547,7 @@ function RightContainer({
 				{allowBucketConfig && (
 					<SettingsSection title="Histogram / Buckets">
 						<section className="bucket-config control-container">
-							<Typography.Text className="section-heading">
-								Number of buckets
-							</Typography.Text>
+							<Typography.Text className="label">Number of buckets</Typography.Text>
 							<InputNumber
 								value={bucketCount || null}
 								type="number"
@@ -637,7 +558,7 @@ function RightContainer({
 									setBucketCount(val || 0);
 								}}
 							/>
-							<Typography.Text className="section-heading bucket-size-label">
+							<Typography.Text className="label bucket-size-label">
 								Bucket width
 							</Typography.Text>
 							<InputNumber
@@ -653,7 +574,7 @@ function RightContainer({
 								}}
 							/>
 							<section className="combine-hist">
-								<Typography.Text className="section-heading">
+								<Typography.Text className="label">
 									Merge all series into one
 								</Typography.Text>
 								<Switch
@@ -761,14 +682,6 @@ export interface RightContainerProps {
 	setContextLinks: Dispatch<SetStateAction<ContextLinksData>>;
 	enableDrillDown?: boolean;
 	isNewDashboard: boolean;
-	lineInterpolation: LineInterpolation;
-	setLineInterpolation: Dispatch<SetStateAction<LineInterpolation>>;
-	fillMode: FillMode;
-	setFillMode: Dispatch<SetStateAction<FillMode>>;
-	lineStyle: LineStyle;
-	setLineStyle: Dispatch<SetStateAction<LineStyle>>;
-	showPoints: boolean;
-	setShowPoints: Dispatch<SetStateAction<boolean>>;
 }
 
 RightContainer.defaultProps = {

frontend/src/container/NewWidget/index.tsx

@@ -6,11 +6,6 @@ import { UseQueryResult } from 'react-query';
 import { useSelector } from 'react-redux';
 import { generatePath } from 'react-router-dom';
 import { WarningOutlined } from '@ant-design/icons';
-import {
-	ResizableHandle,
-	ResizablePanel,
-	ResizablePanelGroup,
-} from '@signozhq/resizable';
 import { Button, Flex, Modal, Space, Typography } from 'antd';
 import logEvent from 'api/common/logEvent';
 import { PrecisionOption, PrecisionOptionsEnum } from 'components/Graph/types';
@@ -29,16 +24,12 @@ import { useDashboardVariables } from 'hooks/dashboard/useDashboardVariables';
 import { useUpdateDashboard } from 'hooks/dashboard/useUpdateDashboard';
 import { useKeyboardHotkeys } from 'hooks/hotkeys/useKeyboardHotkeys';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
+import { useIsDarkMode } from 'hooks/useDarkMode';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
 import createQueryParams from 'lib/createQueryParams';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
 import { getDashboardVariables } from 'lib/dashboardVariables/getDashboardVariables';
-import {
-	FillMode,
-	LineInterpolation,
-	LineStyle,
-} from 'lib/uPlotV2/config/types';
 import { cloneDeep, defaultTo, isEmpty, isUndefined } from 'lodash-es';
 import { Check, X } from 'lucide-react';
 import { useScrollToWidgetIdStore } from 'providers/Dashboard/helpers/scrollToWidgetIdHelper';
@@ -72,7 +63,12 @@ import QueryTypeTag from './LeftContainer/QueryTypeTag';
 import RightContainer from './RightContainer';
 import { ThresholdProps } from './RightContainer/Threshold/types';
 import TimeItems, { timePreferance } from './RightContainer/timeItems';
-import { Container, PanelContainer } from './styles';
+import {
+	Container,
+	LeftContainerWrapper,
+	PanelContainer,
+	RightContainerWrapper,
+} from './styles';
 import { NewWidgetProps } from './types';
 import {
 	getDefaultWidgetData,
@@ -208,18 +204,6 @@ function NewWidget({
 	const [legendPosition, setLegendPosition] = useState<LegendPosition>(
 		selectedWidget?.legendPosition || LegendPosition.BOTTOM,
 	);
-	const [lineInterpolation, setLineInterpolation] = useState<LineInterpolation>(
-		selectedWidget?.lineInterpolation || LineInterpolation.Spline,
-	);
-	const [fillMode, setFillMode] = useState<FillMode>(
-		selectedWidget?.fillMode || FillMode.None,
-	);
-	const [lineStyle, setLineStyle] = useState<LineStyle>(
-		selectedWidget?.lineStyle || LineStyle.Solid,
-	);
-	const [showPoints, setShowPoints] = useState<boolean>(
-		selectedWidget?.showPoints ?? false,
-	);
 	const [customLegendColors, setCustomLegendColors] = useState<
 		Record<string, string>
 	>(selectedWidget?.customLegendColors || {});
@@ -285,10 +269,6 @@ function NewWidget({
 				softMin,
 				softMax,
 				fillSpans: isFillSpans,
-				lineInterpolation,
-				fillMode,
-				lineStyle,
-				showPoints,
 				columnUnits,
 				bucketCount,
 				stackedBarChart,
@@ -324,10 +304,6 @@ function NewWidget({
 		stackedBarChart,
 		isLogScale,
 		legendPosition,
-		lineInterpolation,
-		fillMode,
-		lineStyle,
-		showPoints,
 		customLegendColors,
 		contextLinks,
 		selectedWidget.columnWidths,
@@ -781,7 +757,7 @@ function NewWidget({
 	}, [query, safeNavigate, dashboardId, currentQuery]);
 
 	return (
-		<Container className="new-widget-container">
+		<Container>
 			<div className="edit-header">
 				<div className="left-header">
 					<X
@@ -835,44 +811,31 @@ function NewWidget({
 			</div>
 
 			<PanelContainer>
-				<ResizablePanelGroup
-					direction="horizontal"
-					className="widget-resizable-panel-group"
-					autoSaveId="panel-editor"
-				>
-					<ResizablePanel
-						minSize={70}
-						maxSize={80}
-						defaultSize={80}
-						className="resizable-panel-left-container"
-					>
-						<OverlayScrollbar>
-							{selectedWidget && (
-								<LeftContainer
-									selectedDashboard={selectedDashboard}
-									selectedGraph={graphType}
-									selectedLogFields={selectedLogFields}
-									setSelectedLogFields={setSelectedLogFields}
-									selectedTracesFields={selectedTracesFields}
-									setSelectedTracesFields={setSelectedTracesFields}
-									selectedWidget={selectedWidget}
-									selectedTime={selectedTime}
-									requestData={requestData}
-									setRequestData={setRequestData}
-									isLoadingPanelData={isLoadingPanelData}
-									setQueryResponse={setQueryResponse}
-									enableDrillDown={enableDrillDown}
-								/>
-							)}
-						</OverlayScrollbar>
-					</ResizablePanel>
-					<ResizableHandle withHandle className="widget-resizable-handle" />
-					<ResizablePanel
-						minSize={20}
-						maxSize={30}
-						defaultSize={20}
-						className="resizable-panel-right-container"
-					>
+				<LeftContainerWrapper isDarkMode={useIsDarkMode()}>
+					<OverlayScrollbar>
+						{selectedWidget && (
+							<LeftContainer
+								selectedGraph={graphType}
+								selectedLogFields={selectedLogFields}
+								setSelectedLogFields={setSelectedLogFields}
+								selectedTracesFields={selectedTracesFields}
+								setSelectedTracesFields={setSelectedTracesFields}
+								selectedWidget={selectedWidget}
+								selectedTime={selectedTime}
+								requestData={requestData}
+								setRequestData={setRequestData}
+								isLoadingPanelData={isLoadingPanelData}
+								setQueryResponse={setQueryResponse}
+								enableDrillDown={enableDrillDown}
+								selectedDashboard={selectedDashboard}
+								isNewPanel={isNewPanel}
+							/>
+						)}
+					</OverlayScrollbar>
+				</LeftContainerWrapper>
+
+				<RightContainerWrapper>
+					<OverlayScrollbar>
 						<RightContainer
 							setGraphHandler={setGraphHandler}
 							title={title}
@@ -881,14 +844,6 @@ function NewWidget({
 							setDescription={setDescription}
 							stackedBarChart={stackedBarChart}
 							setStackedBarChart={setStackedBarChart}
-							lineInterpolation={lineInterpolation}
-							setLineInterpolation={setLineInterpolation}
-							fillMode={fillMode}
-							setFillMode={setFillMode}
-							lineStyle={lineStyle}
-							setLineStyle={setLineStyle}
-							showPoints={showPoints}
-							setShowPoints={setShowPoints}
 							opacity={opacity}
 							yAxisUnit={yAxisUnit}
 							columnUnits={columnUnits}
@@ -929,8 +884,8 @@ function NewWidget({
 							enableDrillDown={enableDrillDown}
 							isNewDashboard={isNewDashboard}
 						/>
-					</ResizablePanel>
-				</ResizablePanelGroup>
+					</OverlayScrollbar>
+				</RightContainerWrapper>
 			</PanelContainer>
 			<Modal
 				title={

frontend/src/container/NewWidget/styles.ts

@@ -1,4 +1,4 @@
-import { Tag as AntDTag } from 'antd';
+import { Col, Tag as AntDTag } from 'antd';
 import styled from 'styled-components';
 
 export const Container = styled.div`
@@ -8,6 +8,35 @@ export const Container = styled.div`
 	overflow-y: hidden;
 `;
 
+export const RightContainerWrapper = styled(Col)`
+	&&& {
+		max-width: 400px;
+		width: 30%;
+		overflow-y: auto;
+	}
+	&::-webkit-scrollbar {
+		width: 0rem;
+	}
+`;
+
+interface LeftContainerWrapperProps {
+	isDarkMode: boolean;
+}
+
+export const LeftContainerWrapper = styled(Col)<LeftContainerWrapperProps>`
+	&&& {
+		width: 100%;
+		overflow-y: auto;
+		border-right: ${({ isDarkMode }): string =>
+			isDarkMode
+				? '1px solid var(--bg-slate-300)'
+				: '1px solid var(--bg-vanilla-300)'};
+	}
+	&::-webkit-scrollbar {
+		width: 0rem;
+	}
+`;
+
 export const ButtonContainer = styled.div`
 	display: flex;
 	gap: 8px;

frontend/src/container/NewWidget/utils.ts

@@ -11,8 +11,11 @@ import { getYAxisCategories } from 'components/YAxisUnitSelector/utils';
 import {
 	initialQueryBuilderFormValuesMap,
 	PANEL_TYPES,
-	PANEL_TYPES_INITIAL_QUERY,
 } from 'constants/queryBuilder';
+import {
+	listViewInitialLogQuery,
+	PANEL_TYPES_INITIAL_QUERY,
+} from 'container/DashboardContainer/ComponentsSlider/constants';
 import {
 	defaultLogsSelectedColumns,
 	defaultTraceSelectedColumns,
@@ -546,7 +549,10 @@ export const getDefaultWidgetData = (
 	nullZeroValues: '',
 	opacity: '',
 	panelTypes: name,
-	query: PANEL_TYPES_INITIAL_QUERY[name],
+	query:
+		name === PANEL_TYPES.LIST
+			? listViewInitialLogQuery
+			: PANEL_TYPES_INITIAL_QUERY[name],
 	timePreferance: 'GLOBAL_TIME',
 	softMax: null,
 	softMin: null,

frontend/src/hooks/queryBuilder/useQueryBuilderOperations.ts

@@ -12,8 +12,6 @@ import {
 	ATTRIBUTE_TYPES,
 	initialAutocompleteData,
 	initialQueryBuilderFormValuesMap,
-	listViewInitialLogQuery,
-	listViewInitialTraceQuery,
 	mapOfFormulaToFilters,
 	mapOfQueryFilters,
 	PANEL_TYPES,
@@ -25,6 +23,10 @@ import {
 	metricsUnknownSpaceAggregateOperatorOptions,
 	metricsUnknownTimeAggregateOperatorOptions,
 } from 'constants/queryBuilderOperators';
+import {
+	listViewInitialLogQuery,
+	listViewInitialTraceQuery,
+} from 'container/DashboardContainer/ComponentsSlider/constants';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { getMetricsOperatorsByAttributeType } from 'lib/newQueryBuilder/getMetricsOperatorsByAttributeType';
 import { getOperatorsBySourceAndPanelType } from 'lib/newQueryBuilder/getOperatorsBySourceAndPanelType';

frontend/src/lib/uPlotV2/config/UPlotSeriesBuilder.ts

@@ -3,15 +3,14 @@ import { generateColor } from 'lib/uPlotLib/utils/generateColor';
 import { calculateWidthBasedOnStepInterval } from 'lib/uPlotV2/utils';
 import uPlot, { Series } from 'uplot';
 
-import { generateGradientFill } from '../utils/generateGradientFill';
 import {
 	BarAlignment,
 	ConfigBuilder,
 	DrawStyle,
-	FillMode,
 	LineInterpolation,
 	LineStyle,
 	SeriesProps,
+	VisibilityMode,
 } from './types';
 
 /**
@@ -53,7 +52,7 @@ export class UPlotSeriesBuilder extends ConfigBuilder<SeriesProps, Series> {
 	}: {
 		resolvedLineColor: string;
 	}): Partial<Series> {
-		const { lineWidth, lineStyle, lineCap, fillColor, fillMode } = this.props;
+		const { lineWidth, lineStyle, lineCap, fillColor } = this.props;
 		const lineConfig: Partial<Series> = {
 			stroke: resolvedLineColor,
 			width: lineWidth ?? DEFAULT_LINE_WIDTH,
@@ -67,26 +66,12 @@ export class UPlotSeriesBuilder extends ConfigBuilder<SeriesProps, Series> {
 			lineConfig.cap = lineCap;
 		}
 
-		/**
-		 * Configure area fill based on draw style and fill mode:
-		 * - bar charts always use a solid fill with the series color
-		 * - histogram uses the same color with a fixed alpha suffix for translucency
-		 * - for other series, an explicit fillMode controls whether we use a solid fill
-		 *   or a vertical gradient from the series color to transparent
-		 */
-		const finalFillColor = fillColor ?? resolvedLineColor;
-
-		if (this.props.drawStyle === DrawStyle.Bar) {
-			lineConfig.fill = finalFillColor;
+		if (fillColor) {
+			lineConfig.fill = fillColor;
+		} else if (this.props.drawStyle === DrawStyle.Bar) {
+			lineConfig.fill = resolvedLineColor;
 		} else if (this.props.drawStyle === DrawStyle.Histogram) {
-			lineConfig.fill = `${finalFillColor}40`;
-		} else if (fillMode && fillMode !== FillMode.None) {
-			if (fillMode === FillMode.Solid) {
-				lineConfig.fill = finalFillColor;
-			} else if (fillMode === FillMode.Gradient) {
-				lineConfig.fill = (self: uPlot): CanvasGradient =>
-					generateGradientFill(self, finalFillColor, 'rgba(0, 0, 0, 0)');
-			}
+			lineConfig.fill = `${resolvedLineColor}40`;
 		}
 
 		return lineConfig;
@@ -174,8 +159,12 @@ export class UPlotSeriesBuilder extends ConfigBuilder<SeriesProps, Series> {
 			pointsConfig.show = pointsBuilder;
 		} else if (drawStyle === DrawStyle.Points) {
 			pointsConfig.show = true;
+		} else if (showPoints === VisibilityMode.Never) {
+			pointsConfig.show = false;
+		} else if (showPoints === VisibilityMode.Always) {
+			pointsConfig.show = true;
 		} else {
-			pointsConfig.show = !!showPoints;
+			pointsConfig.show = false; // default to hidden
 		}
 
 		return pointsConfig;

frontend/src/lib/uPlotV2/config/__tests__/UPlotSeriesBuilder.test.ts

@@ -2,7 +2,12 @@ import { themeColors } from 'constants/theme';
 import uPlot from 'uplot';
 
 import type { SeriesProps } from '../types';
-import { DrawStyle, LineInterpolation, LineStyle } from '../types';
+import {
+	DrawStyle,
+	LineInterpolation,
+	LineStyle,
+	VisibilityMode,
+} from '../types';
 import { POINT_SIZE_FACTOR, UPlotSeriesBuilder } from '../UPlotSeriesBuilder';
 
 const createBaseProps = (
@@ -163,17 +168,17 @@ describe('UPlotSeriesBuilder', () => {
 		expect(config.points?.show).toBe(pointsBuilder);
 	});
 
-	it('respects showPoints for point visibility when no custom pointsBuilder is given', () => {
+	it('respects VisibilityMode for point visibility when no custom pointsBuilder is given', () => {
 		const neverPointsBuilder = new UPlotSeriesBuilder(
 			createBaseProps({
 				drawStyle: DrawStyle.Line,
-				showPoints: false,
+				showPoints: VisibilityMode.Never,
 			}),
 		);
 		const alwaysPointsBuilder = new UPlotSeriesBuilder(
 			createBaseProps({
 				drawStyle: DrawStyle.Line,
-				showPoints: true,
+				showPoints: VisibilityMode.Always,
 			}),
 		);
 

frontend/src/lib/uPlotV2/config/types.ts

@@ -122,6 +122,12 @@ export enum LineInterpolation {
 	StepBefore = 'stepBefore',
 }
 
+export enum VisibilityMode {
+	Always = 'always',
+	Auto = 'auto',
+	Never = 'never',
+}
+
 /**
  * Props for configuring lines
  */
@@ -157,13 +163,7 @@ export interface BarConfig {
 export interface PointsConfig {
 	pointColor?: string;
 	pointSize?: number;
-	showPoints?: boolean;
-}
-
-export enum FillMode {
-	Solid = 'solid',
-	Gradient = 'gradient',
-	None = 'none',
+	showPoints?: VisibilityMode;
 }
 
 export interface SeriesProps extends LineConfig, PointsConfig, BarConfig {
@@ -177,7 +177,6 @@ export interface SeriesProps extends LineConfig, PointsConfig, BarConfig {
 	show?: boolean;
 	spanGaps?: boolean;
 	fillColor?: string;
-	fillMode?: FillMode;
 	isDarkMode?: boolean;
 	stepInterval?: number;
 }

frontend/src/lib/uPlotV2/utils/generateGradientFill.ts

@@ -1,18 +0,0 @@
-import uPlot from 'uplot';
-
-export function generateGradientFill(
-	uPlotInstance: uPlot,
-	startColor: string,
-	endColor: string,
-): CanvasGradient {
-	const g = uPlotInstance.ctx.createLinearGradient(
-		0,
-		0,
-		0,
-		uPlotInstance.bbox.height,
-	);
-	g.addColorStop(0, `${startColor}70`);
-	g.addColorStop(0.6, `${startColor}40`);
-	g.addColorStop(1, endColor);
-	return g;
-}

frontend/src/pages/DashboardWidget/__tests__/DashboardWidget.test.tsx

@@ -1,5 +1,4 @@
 import { Route } from 'react-router-dom';
-import * as getDashboardModule from 'api/v1/dashboards/id/get';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { rest, server } from 'mocks-server/server';
 import { render, screen, waitFor } from 'tests/test-utils';
@@ -48,33 +47,35 @@ jest.mock('container/NewWidget', () => ({
 	default: (): JSX.Element => <div data-testid="new-widget">NewWidget</div>,
 }));
 
-// Wrap component in a Route so useParams can resolve dashboardId.
-// Query params are passed via the URL so useUrlQuery (react-router) can read them.
+// nuqs's useQueryState doesn't read from MemoryRouter, so we mock it to return
+// controlled values via the `mockQueryState` map below.
+const mockQueryState: Record<string, string | null> = {};
+
+jest.mock('nuqs', () => ({
+	...jest.requireActual('nuqs'),
+	useQueryState: (key: string): [string | null, jest.Mock] => [
+		mockQueryState[key] ?? null,
+		jest.fn(),
+	],
+}));
+
+// Wrap component in a Route so useParams can resolve dashboardId
 function renderAtRoute(
 	queryState: Record<string, string | null> = {},
 ): ReturnType<typeof render> {
-	const params = new URLSearchParams();
-	Object.entries(queryState).forEach(([k, v]) => {
-		if (v !== null) {
-			params.set(k, v);
-		}
-	});
-	const search = params.toString() ? `?${params.toString()}` : '';
+	Object.assign(mockQueryState, queryState);
 	return render(
 		<Route path="/dashboard/:dashboardId/new">
 			<DashboardWidget />
 		</Route>,
 		undefined,
-		{ initialRoute: `/dashboard/${DASHBOARD_ID}/new${search}` },
+		{ initialRoute: `/dashboard/${DASHBOARD_ID}/new` },
 	);
 }
 
 beforeEach(() => {
 	mockSafeNavigate.mockClear();
-});
-
-afterEach(() => {
-	jest.restoreAllMocks();
+	Object.keys(mockQueryState).forEach((k) => delete mockQueryState[k]);
 });
 
 describe('DashboardWidget', () => {
@@ -101,10 +102,12 @@ describe('DashboardWidget', () => {
 	});
 
 	it('shows spinner while dashboard is loading', () => {
-		// Spy instead of MSW delay('infinite') to avoid leaving an open network handle.
-		jest
-			.spyOn(getDashboardModule, 'default')
-			.mockReturnValue(new Promise(() => {}));
+		server.use(
+			rest.get(
+				`http://localhost/api/v1/dashboards/${DASHBOARD_ID}`,
+				(_req, res, ctx) => res(ctx.delay('infinite')),
+			),
+		);
 
 		renderAtRoute({ widgetId: WIDGET_ID, graphType: PANEL_TYPES.TIME_SERIES });
 

frontend/src/pages/DashboardWidget/index.tsx

@@ -1,11 +1,10 @@
-import { useEffect, useMemo, useState } from 'react';
+import { useEffect, useState } from 'react';
 import { useQuery } from 'react-query';
 import { generatePath, useParams } from 'react-router-dom';
 import { Card, Typography } from 'antd';
 import getDashboard from 'api/v1/dashboards/id/get';
 import Spinner from 'components/Spinner';
 import { SOMETHING_WENT_WRONG } from 'constants/api';
-import { QueryParams } from 'constants/query';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { DASHBOARD_CACHE_TIME } from 'constants/queryCacheTime';
 import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
@@ -14,7 +13,7 @@ import NewWidget from 'container/NewWidget';
 import { isDrilldownEnabled } from 'container/QueryTable/Drilldown/drilldownUtils';
 import { useTransformDashboardVariables } from 'hooks/dashboard/useTransformDashboardVariables';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
-import useUrlQuery from 'hooks/useUrlQuery';
+import { parseAsStringEnum, useQueryState } from 'nuqs';
 import { setDashboardVariablesStore } from 'providers/Dashboard/store/dashboardVariables/dashboardVariablesStore';
 import { Dashboard } from 'types/api/dashboard/getAll';
 
@@ -22,13 +21,11 @@ function DashboardWidget(): JSX.Element | null {
 	const { dashboardId } = useParams<{
 		dashboardId: string;
 	}>();
-	const query = useUrlQuery();
-	const { graphType, widgetId } = useMemo(() => {
-		return {
-			graphType: query.get(QueryParams.graphType) as PANEL_TYPES,
-			widgetId: query.get(QueryParams.widgetId),
-		};
-	}, [query]);
+	const [widgetId] = useQueryState('widgetId');
+	const [graphType] = useQueryState(
+		'graphType',
+		parseAsStringEnum<PANEL_TYPES>(Object.values(PANEL_TYPES)),
+	);
 
 	const { safeNavigate } = useSafeNavigate();
 

frontend/src/providers/Dashboard/Dashboard.tsx

@@ -53,7 +53,9 @@ import { IDashboardContext, WidgetColumnWidths } from './types';
 import { sortLayout } from './util';
 
 export const DashboardContext = createContext<IDashboardContext>({
+	isDashboardSliderOpen: false,
 	isDashboardLocked: false,
+	handleToggleDashboardSlider: () => {},
 	handleDashboardLockToggle: () => {},
 	dashboardResponse: {} as UseQueryResult<
 		SuccessResponseV2<Dashboard>,
@@ -80,6 +82,8 @@ export function DashboardProvider({
 	children,
 	dashboardId,
 }: PropsWithChildren<{ dashboardId: string }>): JSX.Element {
+	const [isDashboardSliderOpen, setIsDashboardSlider] = useState<boolean>(false);
+
 	const [isDashboardLocked, setIsDashboardLocked] = useState<boolean>(false);
 
 	const [
@@ -284,8 +288,13 @@ export function DashboardProvider({
 		}
 	}, [isVisible]);
 
+	const handleToggleDashboardSlider = (value: boolean): void => {
+		setIsDashboardSlider(value);
+	};
+
 	const { mutate: lockDashboard } = useMutation(locked, {
 		onSuccess: (_, props) => {
+			setIsDashboardSlider(false);
 			setIsDashboardLocked(props.lock);
 		},
 		onError: (error) => {
@@ -310,7 +319,9 @@ export function DashboardProvider({
 
 	const value: IDashboardContext = useMemo(
 		() => ({
+			isDashboardSliderOpen,
 			isDashboardLocked,
+			handleToggleDashboardSlider,
 			handleDashboardLockToggle,
 			dashboardResponse,
 			selectedDashboard,
@@ -330,6 +341,7 @@ export function DashboardProvider({
 		}),
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 		[
+			isDashboardSliderOpen,
 			isDashboardLocked,
 			dashboardResponse,
 			selectedDashboard,

frontend/src/providers/Dashboard/helpers/panelTypeSelectionModalHelper.ts

@@ -1,18 +0,0 @@
-import { create } from 'zustand';
-
-interface IPanelTypeSelectionModalState {
-	isPanelTypeSelectionModalOpen: boolean;
-	setIsPanelTypeSelectionModalOpen: (isOpen: boolean) => void;
-}
-
-/**
- * This helper is used for selecting the panel type when creating a new panel in the dashboard.
- * It uses Zustand for state management to keep track of whether the panel type selection modal is open or closed.
- */
-export const usePanelTypeSelectionModalStore = create<IPanelTypeSelectionModalState>(
-	(set) => ({
-		isPanelTypeSelectionModalOpen: false,
-		setIsPanelTypeSelectionModalOpen: (isOpen): void =>
-			set({ isPanelTypeSelectionModalOpen: isOpen }),
-	}),
-);

frontend/src/providers/Dashboard/types.ts

@@ -9,7 +9,9 @@ export type WidgetColumnWidths = {
 };
 
 export interface IDashboardContext {
+	isDashboardSliderOpen: boolean;
 	isDashboardLocked: boolean;
+	handleToggleDashboardSlider: (value: boolean) => void;
 	handleDashboardLockToggle: (value: boolean) => void;
 	dashboardResponse: UseQueryResult<SuccessResponseV2<Dashboard>, unknown>;
 	selectedDashboard: Dashboard | undefined;

frontend/src/types/api/dashboard/getAll.ts

@@ -5,11 +5,6 @@ import { PANEL_GROUP_TYPES, PANEL_TYPES } from 'constants/queryBuilder';
 import { ThresholdProps } from 'container/NewWidget/RightContainer/Threshold/types';
 import { timePreferenceType } from 'container/NewWidget/RightContainer/timeItems';
 import { QueryTableProps } from 'container/QueryTable/QueryTable.intefaces';
-import {
-	FillMode,
-	LineInterpolation,
-	LineStyle,
-} from 'lib/uPlotV2/config/types';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 
 import { IField } from '../logs/fields';
@@ -137,10 +132,6 @@ export interface IBaseWidget {
 	legendPosition?: LegendPosition;
 	customLegendColors?: Record<string, string>;
 	contextLinks?: ContextLinksData;
-	lineInterpolation?: LineInterpolation;
-	showPoints?: boolean;
-	lineStyle?: LineStyle;
-	fillMode?: FillMode;
 }
 export interface Widgets extends IBaseWidget {
 	query: Query;

frontend/yarn.lock

@@ -5646,7 +5646,7 @@
     tailwind-merge "^2.5.2"
     tailwindcss-animate "^1.0.7"
 
-"@signozhq/toggle-group@0.0.1":
+"@signozhq/toggle-group@^0.0.1":
   version "0.0.1"
   resolved "https://registry.yarnpkg.com/@signozhq/toggle-group/-/toggle-group-0.0.1.tgz#c82ff1da34e77b24da53c2d595ad6b4a0d1b1de4"
   integrity sha512-871bQayL5MaqsuNOFHKexidu9W2Hlg1y4xmH8C5mGmlfZ4bd0ovJ9OweQrM6Puys3jeMwi69xmJuesYCfKQc1g==

go.mod

@@ -11,7 +11,6 @@ require (
 	github.com/SigNoz/signoz-otel-collector v0.144.2
 	github.com/antlr4-go/antlr/v4 v4.13.1
 	github.com/antonmedv/expr v1.15.3
-	github.com/bytedance/sonic v1.14.1
 	github.com/cespare/xxhash/v2 v2.3.0
 	github.com/coreos/go-oidc/v3 v3.17.0
 	github.com/dgraph-io/ristretto/v2 v2.3.0
@@ -106,6 +105,7 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/sts v1.41.6 // indirect
 	github.com/aws/smithy-go v1.24.0 // indirect
 	github.com/bytedance/gopkg v0.1.3 // indirect
+	github.com/bytedance/sonic v1.14.1 // indirect
 	github.com/bytedance/sonic/loader v0.3.0 // indirect
 	github.com/cloudwego/base64x v0.1.6 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.8 // indirect

pkg/instrumentation/loghandler/filtering.go

@@ -1,41 +0,0 @@
-package loghandler
-
-import (
-	"context"
-	"log/slog"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-)
-
-type filtering struct{}
-
-func NewFiltering() *filtering {
-	return &filtering{}
-}
-
-func (h *filtering) Wrap(next LogHandler) LogHandler {
-	return LogHandlerFunc(func(ctx context.Context, record slog.Record) error {
-		if !filterRecord(record) {
-			return nil
-		}
-
-		return next.Handle(ctx, record)
-	})
-}
-
-func filterRecord(record slog.Record) bool {
-	suppress := false
-	record.Attrs(func(a slog.Attr) bool {
-		if a.Value.Kind() == slog.KindAny {
-			if err, ok := a.Value.Any().(error); ok {
-				if errors.Is(err, context.Canceled) {
-					suppress = true
-					return false
-				}
-			}
-		}
-		return true
-	})
-
-	return !suppress
-}

pkg/instrumentation/loghandler/filtering_test.go

@@ -1,52 +0,0 @@
-package loghandler
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"log/slog"
-	"testing"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestFiltering_SuppressesContextCanceled(t *testing.T) {
-	filtering := NewFiltering()
-
-	buf := bytes.NewBuffer(nil)
-	logger := slog.New(&handler{base: slog.NewJSONHandler(buf, &slog.HandlerOptions{Level: slog.LevelDebug}), wrappers: []Wrapper{filtering}})
-
-	logger.ErrorContext(context.Background(), "operation failed", "error", context.Canceled)
-
-	assert.Empty(t, buf.String(), "log with context.Canceled should be suppressed")
-}
-
-func TestFiltering_AllowsOtherErrors(t *testing.T) {
-	filtering := NewFiltering()
-
-	buf := bytes.NewBuffer(nil)
-	logger := slog.New(&handler{base: slog.NewJSONHandler(buf, &slog.HandlerOptions{Level: slog.LevelDebug}), wrappers: []Wrapper{filtering}})
-
-	logger.ErrorContext(context.Background(), "operation failed", "error", errors.New(errors.TypeInternal, errors.CodeInternal, "some other error"))
-
-	m := make(map[string]any)
-	err := json.Unmarshal(buf.Bytes(), &m)
-	require.NoError(t, err)
-	assert.Equal(t, "operation failed", m["msg"])
-}
-
-func TestFiltering_AllowsLogsWithoutErrors(t *testing.T) {
-	filtering := NewFiltering()
-
-	buf := bytes.NewBuffer(nil)
-	logger := slog.New(&handler{base: slog.NewJSONHandler(buf, &slog.HandlerOptions{Level: slog.LevelDebug}), wrappers: []Wrapper{filtering}})
-
-	logger.InfoContext(context.Background(), "normal log", "key", "value")
-
-	m := make(map[string]any)
-	err := json.Unmarshal(buf.Bytes(), &m)
-	require.NoError(t, err)
-	assert.Equal(t, "normal log", m["msg"])
-}

pkg/instrumentation/sdk.go

@@ -116,7 +116,7 @@ func New(ctx context.Context, cfg Config, build version.Build, serviceName strin
 		meterProvider:             meterProvider,
 		meterProviderShutdownFunc: meterProviderShutdownFunc,
 		prometheusRegistry:        prometheusRegistry,
-		logger:                    NewLogger(cfg, loghandler.NewCorrelation(), loghandler.NewFiltering()),
+		logger:                    NewLogger(cfg, loghandler.NewCorrelation()),
 		startCh:                   make(chan struct{}),
 	}, nil
 }

pkg/modules/promote/implpromote/module.go

@@ -78,7 +78,7 @@ func (m *module) ListPromotedAndIndexedPaths(ctx context.Context) ([]promotetype
 
 	// add the paths that are not promoted but have indexes
 	for path, indexes := range aggr {
-		path := strings.TrimPrefix(path, telemetrylogs.BodyJSONColumnPrefix)
+		path := strings.TrimPrefix(path, telemetrylogs.BodyV2ColumnPrefix)
 		path = telemetrytypes.BodyJSONStringSearchPrefix + path
 		response = append(response, promotetypes.PromotePath{
 			Path:    path,
@@ -163,7 +163,7 @@ func (m *module) PromoteAndIndexPaths(
 			}
 		}
 		if len(it.Indexes) > 0 {
-			parentColumn := telemetrylogs.LogsV2BodyJSONColumn
+			parentColumn := telemetrylogs.LogsV2BodyV2Column
 			// if the path is already promoted or is being promoted, add it to the promoted column
 			if _, promoted := existingPromotedPaths[it.Path]; promoted || it.Promote {
 				parentColumn = telemetrylogs.LogsV2BodyPromotedColumn

pkg/querier/builder_query.go

@@ -10,13 +10,11 @@ import (
 
 	"github.com/ClickHouse/clickhouse-go/v2"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/telemetrylogs"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	"github.com/SigNoz/signoz/pkg/types/instrumentationtypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/bytedance/sonic"
 )
 
 type builderQuery[T any] struct {
@@ -262,40 +260,6 @@ func (q *builderQuery[T]) executeWithContext(ctx context.Context, query string,
 		return nil, err
 	}
 
-	// merge body_json and promoted into body
-	if q.spec.Signal == telemetrytypes.SignalLogs {
-		switch typedPayload := payload.(type) {
-		case *qbtypes.RawData:
-			for _, rr := range typedPayload.Rows {
-				seeder := func() error {
-					body, ok := rr.Data[telemetrylogs.LogsV2BodyJSONColumn].(map[string]any)
-					if !ok {
-						return nil
-					}
-					promoted, ok := rr.Data[telemetrylogs.LogsV2BodyPromotedColumn].(map[string]any)
-					if !ok {
-						return nil
-					}
-					seed(promoted, body)
-					str, err := sonic.MarshalString(body)
-					if err != nil {
-						return errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to marshal body")
-					}
-					rr.Data["body"] = str
-					return nil
-				}
-				err := seeder()
-				if err != nil {
-					return nil, err
-				}
-
-				delete(rr.Data, telemetrylogs.LogsV2BodyJSONColumn)
-				delete(rr.Data, telemetrylogs.LogsV2BodyPromotedColumn)
-			}
-			payload = typedPayload
-		}
-	}
-
 	return &qbtypes.Result{
 		Type:  q.kind,
 		Value: payload,
@@ -423,18 +387,3 @@ func decodeCursor(cur string) (int64, error) {
 	}
 	return strconv.ParseInt(string(b), 10, 64)
 }
-
-func seed(promoted map[string]any, body map[string]any) {
-	for key, fromValue := range promoted {
-		if toValue, ok := body[key]; !ok {
-			body[key] = fromValue
-		} else {
-			if fromValue, ok := fromValue.(map[string]any); ok {
-				if toValue, ok := toValue.(map[string]any); ok {
-					seed(fromValue, toValue)
-					body[key] = toValue
-				}
-			}
-		}
-	}
-}

pkg/querier/consume.go

@@ -14,7 +14,6 @@ import (
 	"github.com/ClickHouse/clickhouse-go/v2/lib/driver"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/bytedance/sonic"
 )
 
 var (
@@ -394,17 +393,11 @@ func readAsRaw(rows driver.Rows, queryName string) (*qbtypes.RawData, error) {
 
 			// de-reference the typed pointer to any
 			val := reflect.ValueOf(cellPtr).Elem().Interface()
-
-			// Post-process JSON columns: normalize into structured values
+			// Post-process JSON columns: normalize into String value
 			if strings.HasPrefix(strings.ToUpper(colTypes[i].DatabaseTypeName()), "JSON") {
 				switch x := val.(type) {
 				case []byte:
-					if len(x) > 0 {
-						var v any
-						if err := sonic.Unmarshal(x, &v); err == nil {
-							val = v
-						}
-					}
+					val = string(x)
 				default:
 					// already a structured type (map[string]any, []any, etc.)
 				}

pkg/query-service/agentConf/db.go

@@ -7,14 +7,13 @@ import (
 	"strings"
 	"time"
 
-	"log/slog"
-
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/opamptypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
+	"go.uber.org/zap"
 	"golang.org/x/exp/slices"
 )
 
@@ -122,7 +121,7 @@ func (r *Repo) insertConfig(
 
 	// allowing empty elements for logs - use case is deleting all pipelines
 	if len(elements) == 0 && c.ElementType != opamptypes.ElementTypeLogPipelines {
-		slog.ErrorContext(ctx, "insert config called with no elements", "element_type", c.ElementType.StringValue())
+		zap.L().Error("insert config called with no elements ", zap.String("ElementType", c.ElementType.StringValue()))
 		return errors.NewInvalidInputf(CodeConfigElementsRequired, "config must have atleast one element")
 	}
 
@@ -130,13 +129,13 @@ func (r *Repo) insertConfig(
 		// the version can not be set by the user, we want to auto-assign the versions
 		// in a monotonically increasing order starting with 1. hence, we reject insert
 		// requests with version anything other than 0. here, 0 indicates un-assigned
-		slog.ErrorContext(ctx, "invalid version assignment while inserting agent config", "version", c.Version, "element_type", c.ElementType.StringValue())
+		zap.L().Error("invalid version assignment while inserting agent config", zap.Int("version", c.Version), zap.String("ElementType", c.ElementType.StringValue()))
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "user defined versions are not supported in the agent config")
 	}
 
 	configVersion, err := r.GetLatestVersion(ctx, orgId, c.ElementType)
 	if err != nil && !errors.Ast(err, errors.TypeNotFound) {
-		slog.ErrorContext(ctx, "failed to fetch latest config version", "error", err)
+		zap.L().Error("failed to fetch latest config version", zap.Error(err))
 		return err
 	}
 
@@ -156,11 +155,11 @@ func (r *Repo) insertConfig(
 			// Delete elements first, then version (to respect potential foreign key constraints)
 			_, delErr := r.store.BunDB().NewDelete().Model(new(opamptypes.AgentConfigElement)).Where("version_id = ?", c.ID).Exec(ctx)
 			if delErr != nil {
-				slog.ErrorContext(ctx, "failed to delete config elements during cleanup", "error", delErr, "version_id", c.ID.String())
+				zap.L().Error("failed to delete config elements during cleanup", zap.Error(delErr), zap.String("version_id", c.ID.String()))
 			}
 			_, delErr = r.store.BunDB().NewDelete().Model(new(opamptypes.AgentConfigVersion)).Where("id = ?", c.ID).Where("org_id = ?", orgId).Exec(ctx)
 			if delErr != nil {
-				slog.ErrorContext(ctx, "failed to delete config version during cleanup", "error", delErr, "version_id", c.ID.String())
+				zap.L().Error("failed to delete config version during cleanup", zap.Error(delErr), zap.String("version_id", c.ID.String()))
 			}
 		}
 	}()
@@ -171,7 +170,7 @@ func (r *Repo) insertConfig(
 		Model(c).
 		Exec(ctx)
 	if dbErr != nil {
-		slog.ErrorContext(ctx, "error in inserting config version", "error", dbErr)
+		zap.L().Error("error in inserting config version: ", zap.Error(dbErr))
 		return errors.WrapInternalf(dbErr, CodeConfigVersionInsertFailed, "failed to insert config version")
 	}
 
@@ -222,7 +221,7 @@ func (r *Repo) updateDeployStatus(ctx context.Context,
 		Where("org_id = ?", orgId).
 		Exec(ctx)
 	if err != nil {
-		slog.ErrorContext(ctx, "failed to update deploy status", "error", err)
+		zap.L().Error("failed to update deploy status", zap.Error(err))
 		return model.BadRequest(fmt.Errorf("failed to update deploy status"))
 	}
 
@@ -240,7 +239,7 @@ func (r *Repo) updateDeployStatusByHash(
 		Where("org_id = ?", orgId).
 		Exec(ctx)
 	if err != nil {
-		slog.ErrorContext(ctx, "failed to update deploy status", "error", err)
+		zap.L().Error("failed to update deploy status", zap.Error(err))
 		return errors.WrapInternalf(err, CodeConfigDeployStatusUpdateFailed, "failed to update deploy status")
 	}
 

pkg/query-service/agentConf/manager.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"crypto/sha256"
 	"fmt"
-	"log/slog"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -18,6 +17,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/opamptypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/google/uuid"
+	"go.uber.org/zap"
 	yaml "gopkg.in/yaml.v3"
 )
 
@@ -36,8 +36,7 @@ type AgentFeatureType string
 type Manager struct {
 	Repo
 	// lock to make sure only one update is sent to remote agents at a time
-	lock   uint32
-	logger *slog.Logger
+	lock uint32
 
 	// For AgentConfigProvider implementation
 	agentFeatures         []AgentFeature
@@ -68,7 +67,6 @@ func Initiate(options *ManagerOptions) (*Manager, error) {
 
 	m = &Manager{
 		Repo:              Repo{options.Store},
-		logger:            slog.Default(),
 		agentFeatures:     options.AgentFeatures,
 		configSubscribers: map[string]func(){},
 	}
@@ -224,19 +222,19 @@ func NotifyConfigUpdate(ctx context.Context) {
 func Redeploy(ctx context.Context, orgId valuer.UUID, typ opamptypes.ElementType, version int) error {
 	configVersion, err := GetConfigVersion(ctx, orgId, typ, version)
 	if err != nil {
-		slog.ErrorContext(ctx, "failed to fetch config version during redeploy", "error", err)
+		zap.L().Error("failed to fetch config version during redeploy", zap.Error(err))
 		return err
 	}
 
 	if configVersion == nil || (configVersion != nil && configVersion.Config == "") {
-		slog.DebugContext(ctx, "config version has no conf yaml", "config_version", configVersion)
+		zap.L().Debug("config version has no conf yaml", zap.Any("configVersion", configVersion))
 		return errors.NewInvalidInputf(CodeConfigVersionNoConfig, "the config version can not be redeployed")
 	}
 	switch typ {
 	case opamptypes.ElementTypeSamplingRules:
 		var config *tsp.Config
 		if err := yaml.Unmarshal([]byte(configVersion.Config), &config); err != nil {
-			slog.DebugContext(ctx, "failed to read last conf correctly", "error", err)
+			zap.L().Debug("failed to read last conf correctly", zap.Error(err))
 			return model.BadRequest(fmt.Errorf("failed to read the stored config correctly"))
 		}
 
@@ -248,7 +246,7 @@ func Redeploy(ctx context.Context, orgId valuer.UUID, typ opamptypes.ElementType
 		opamp.AddToTracePipelineSpec("signoz_tail_sampling")
 		configHash, err := opamp.UpsertControlProcessors(ctx, "traces", processorConf, m.OnConfigUpdate)
 		if err != nil {
-			slog.ErrorContext(ctx, "failed to call agent config update for trace processor", "error", err)
+			zap.L().Error("failed to call agent config update for trace processor", zap.Error(err))
 			return errors.WithAdditionalf(err, "failed to deploy the config")
 		}
 
@@ -256,7 +254,7 @@ func Redeploy(ctx context.Context, orgId valuer.UUID, typ opamptypes.ElementType
 	case opamptypes.ElementTypeDropRules:
 		var filterConfig *filterprocessor.Config
 		if err := yaml.Unmarshal([]byte(configVersion.Config), &filterConfig); err != nil {
-			slog.ErrorContext(ctx, "failed to read last conf correctly", "error", err)
+			zap.L().Error("failed to read last conf correctly", zap.Error(err))
 			return model.InternalError(fmt.Errorf("failed to read the stored config correctly"))
 		}
 		processorConf := map[string]interface{}{
@@ -266,7 +264,7 @@ func Redeploy(ctx context.Context, orgId valuer.UUID, typ opamptypes.ElementType
 		opamp.AddToMetricsPipelineSpec("filter")
 		configHash, err := opamp.UpsertControlProcessors(ctx, "metrics", processorConf, m.OnConfigUpdate)
 		if err != nil {
-			slog.ErrorContext(ctx, "failed to call agent config update for trace processor", "error", err)
+			zap.L().Error("failed to call agent config update for trace processor", zap.Error(err))
 			return err
 		}
 
@@ -292,13 +290,13 @@ func UpsertFilterProcessor(ctx context.Context, orgId valuer.UUID, version int,
 	opamp.AddToMetricsPipelineSpec("filter")
 	configHash, err := opamp.UpsertControlProcessors(ctx, "metrics", processorConf, m.OnConfigUpdate)
 	if err != nil {
-		slog.ErrorContext(ctx, "failed to call agent config update for trace processor", "error", err)
+		zap.L().Error("failed to call agent config update for trace processor", zap.Error(err))
 		return err
 	}
 
 	processorConfYaml, yamlErr := yaml.Marshal(config)
 	if yamlErr != nil {
-		slog.WarnContext(ctx, "unexpected error while transforming processor config to yaml", "error", yamlErr)
+		zap.L().Warn("unexpected error while transforming processor config to yaml", zap.Error(yamlErr))
 	}
 
 	m.updateDeployStatus(ctx, orgId, opamptypes.ElementTypeDropRules, version, opamptypes.DeployInitiated.StringValue(), "Deployment started", configHash, string(processorConfYaml))
@@ -317,7 +315,7 @@ func (m *Manager) OnConfigUpdate(orgId valuer.UUID, agentId string, hash string,
 	message := "Deployment was successful"
 
 	defer func() {
-		m.logger.Info(status, "agent_id", agentId, "agent_response", message)
+		zap.L().Info(status, zap.String("agentId", agentId), zap.String("agentResponse", message))
 	}()
 
 	if err != nil {
@@ -343,13 +341,13 @@ func UpsertSamplingProcessor(ctx context.Context, orgId valuer.UUID, version int
 	opamp.AddToTracePipelineSpec("signoz_tail_sampling")
 	configHash, err := opamp.UpsertControlProcessors(ctx, "traces", processorConf, m.OnConfigUpdate)
 	if err != nil {
-		slog.ErrorContext(ctx, "failed to call agent config update for trace processor", "error", err)
+		zap.L().Error("failed to call agent config update for trace processor", zap.Error(err))
 		return err
 	}
 
 	processorConfYaml, yamlErr := yaml.Marshal(config)
 	if yamlErr != nil {
-		slog.WarnContext(ctx, "unexpected error while transforming processor config to yaml", "error", yamlErr)
+		zap.L().Warn("unexpected error while transforming processor config to yaml", zap.Error(yamlErr))
 	}
 
 	m.updateDeployStatus(ctx, orgId, opamptypes.ElementTypeSamplingRules, version, opamptypes.DeployInitiated.StringValue(), "Deployment started", configHash, string(processorConfYaml))

pkg/query-service/app/clickhouseReader/filter_suggestions.go

@@ -11,6 +11,7 @@ import (
 	"github.com/SigNoz/signoz-otel-collector/utils/fingerprint"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
+	"go.uber.org/zap"
 )
 
 func (r *ClickHouseReader) GetQBFilterSuggestionsForLogs(
@@ -78,7 +79,7 @@ func (r *ClickHouseReader) GetQBFilterSuggestionsForLogs(
 		)
 		if err != nil {
 			// Do not fail the entire request if only example query generation fails
-			r.logger.ErrorContext(ctx, "could not find attribute values for creating example query", "error", err)
+			zap.L().Error("could not find attribute values for creating example query", zap.Error(err))
 		} else {
 
 			// add example queries for as many attributes as possible.
@@ -158,7 +159,10 @@ func (r *ClickHouseReader) getValuesForLogAttributes(
 	*/
 
 	if len(attributes) > 10 {
-		r.logger.ErrorContext(ctx, "log attribute values requested for too many attributes. This can lead to slow and costly queries", "count", len(attributes))
+		zap.L().Error(
+			"log attribute values requested for too many attributes. This can lead to slow and costly queries",
+			zap.Int("count", len(attributes)),
+		)
 		attributes = attributes[:10]
 	}
 
@@ -183,7 +187,7 @@ func (r *ClickHouseReader) getValuesForLogAttributes(
 
 	rows, err := r.db.Query(ctx, query, tagKeyQueryArgs...)
 	if err != nil {
-		r.logger.ErrorContext(ctx, "couldn't query attrib values for suggestions", "error", err)
+		zap.L().Error("couldn't query attrib values for suggestions", zap.Error(err))
 		return nil, model.InternalError(fmt.Errorf(
 			"couldn't query attrib values for suggestions: %w", err,
 		))

pkg/query-service/app/clickhouseReader/query_progress/inmemory_tracker.go

@@ -2,18 +2,17 @@ package queryprogress
 
 import (
 	"fmt"
-	"log/slog"
 	"sync"
 
 	"github.com/ClickHouse/clickhouse-go/v2"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 	"github.com/google/uuid"
+	"go.uber.org/zap"
 	"golang.org/x/exp/maps"
 )
 
 // tracks progress and manages subscriptions for all queries
 type inMemoryQueryProgressTracker struct {
-	logger  *slog.Logger
 	queries map[string]*queryTracker
 	lock    sync.RWMutex
 }
@@ -31,7 +30,7 @@ func (tracker *inMemoryQueryProgressTracker) ReportQueryStarted(
 		))
 	}
 
-	tracker.queries[queryId] = newQueryTracker(tracker.logger, queryId)
+	tracker.queries[queryId] = newQueryTracker(queryId)
 
 	return func() {
 		tracker.onQueryFinished(queryId)
@@ -94,7 +93,6 @@ func (tracker *inMemoryQueryProgressTracker) getQueryTracker(
 
 // Tracks progress and manages subscriptions for a single query
 type queryTracker struct {
-	logger     *slog.Logger
 	queryId    string
 	isFinished bool
 
@@ -104,9 +102,8 @@ type queryTracker struct {
 	lock sync.Mutex
 }
 
-func newQueryTracker(logger *slog.Logger, queryId string) *queryTracker {
+func newQueryTracker(queryId string) *queryTracker {
 	return &queryTracker{
-		logger:        logger,
 		queryId:       queryId,
 		subscriptions: map[string]*queryProgressSubscription{},
 	}
@@ -117,7 +114,10 @@ func (qt *queryTracker) handleProgressUpdate(p *clickhouse.Progress) {
 	defer qt.lock.Unlock()
 
 	if qt.isFinished {
-		qt.logger.Warn("received clickhouse progress update for finished query", "queryId", qt.queryId, "progress", p)
+		zap.L().Warn(
+			"received clickhouse progress update for finished query",
+			zap.String("queryId", qt.queryId), zap.Any("progress", p),
+		)
 		return
 	}
 
@@ -146,7 +146,7 @@ func (qt *queryTracker) subscribe() (
 	}
 
 	subscriberId := uuid.NewString()
-	subscription := newQueryProgressSubscription(qt.logger)
+	subscription := newQueryProgressSubscription()
 	qt.subscriptions[subscriberId] = subscription
 
 	if qt.progress != nil {
@@ -163,7 +163,11 @@ func (qt *queryTracker) unsubscribe(subscriberId string) {
 	defer qt.lock.Unlock()
 
 	if qt.isFinished {
-		qt.logger.Debug("received unsubscribe request after query finished", "subscriber", subscriberId, "queryId", qt.queryId)
+		zap.L().Debug(
+			"received unsubscribe request after query finished",
+			zap.String("subscriber", subscriberId),
+			zap.String("queryId", qt.queryId),
+		)
 		return
 	}
 
@@ -179,7 +183,10 @@ func (qt *queryTracker) onFinished() {
 	defer qt.lock.Unlock()
 
 	if qt.isFinished {
-		qt.logger.Warn("receiver query finish report after query finished", "queryId", qt.queryId)
+		zap.L().Warn(
+			"receiver query finish report after query finished",
+			zap.String("queryId", qt.queryId),
+		)
 		return
 	}
 
@@ -192,17 +199,15 @@ func (qt *queryTracker) onFinished() {
 }
 
 type queryProgressSubscription struct {
-	logger   *slog.Logger
 	ch       chan model.QueryProgress
 	isClosed bool
 	lock     sync.Mutex
 }
 
-func newQueryProgressSubscription(logger *slog.Logger) *queryProgressSubscription {
+func newQueryProgressSubscription() *queryProgressSubscription {
 	ch := make(chan model.QueryProgress, 1000)
 	return &queryProgressSubscription{
-		logger: logger,
-		ch:     ch,
+		ch: ch,
 	}
 }
 
@@ -212,7 +217,10 @@ func (ch *queryProgressSubscription) send(progress model.QueryProgress) {
 	defer ch.lock.Unlock()
 
 	if ch.isClosed {
-		ch.logger.Error("can't send query progress: channel already closed.", "progress", progress)
+		zap.L().Error(
+			"can't send query progress: channel already closed.",
+			zap.Any("progress", progress),
+		)
 		return
 	}
 
@@ -220,9 +228,12 @@ func (ch *queryProgressSubscription) send(progress model.QueryProgress) {
 	// blocking while sending doesn't happen in the happy path
 	select {
 	case ch.ch <- progress:
-		ch.logger.Debug("published query progress", "progress", progress)
+		zap.L().Debug("published query progress", zap.Any("progress", progress))
 	default:
-		ch.logger.Error("couldn't publish query progress. dropping update.", "progress", progress)
+		zap.L().Error(
+			"couldn't publish query progress. dropping update.",
+			zap.Any("progress", progress),
+		)
 	}
 }
 

pkg/query-service/app/clickhouseReader/query_progress/tracker.go

@@ -1,8 +1,6 @@
 package queryprogress
 
 import (
-	"log/slog"
-
 	"github.com/ClickHouse/clickhouse-go/v2"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 )
@@ -23,11 +21,10 @@ type QueryProgressTracker interface {
 	SubscribeToQueryProgress(queryId string) (ch <-chan model.QueryProgress, unsubscribe func(), apiErr *model.ApiError)
 }
 
-func NewQueryProgressTracker(logger *slog.Logger) QueryProgressTracker {
+func NewQueryProgressTracker() QueryProgressTracker {
 	// InMemory tracker is useful only for single replica query service setups.
 	// Multi replica setups must use a centralized store for tracking and subscribing to query progress
 	return &inMemoryQueryProgressTracker{
-		logger:  logger,
 		queries: map[string]*queryTracker{},
 	}
 }

pkg/query-service/app/clickhouseReader/query_progress/tracker_test.go

@@ -1,7 +1,6 @@
 package queryprogress
 
 import (
-	"log/slog"
 	"testing"
 	"time"
 
@@ -13,7 +12,7 @@ import (
 func TestQueryProgressTracking(t *testing.T) {
 	require := require.New(t)
 
-	tracker := NewQueryProgressTracker(slog.Default())
+	tracker := NewQueryProgressTracker()
 
 	testQueryId := "test-query"
 

pkg/query-service/app/http_handler.go

@@ -13,7 +13,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/queryparser"
 
 	"io"
-	"log/slog"
 	"math"
 	"net/http"
 	"regexp"
@@ -74,6 +73,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	traceFunnels "github.com/SigNoz/signoz/pkg/types/tracefunneltypes"
 
+	"go.uber.org/zap"
+
 	"github.com/SigNoz/signoz/pkg/query-service/app/integrations/messagingQueues/kafka"
 	"github.com/SigNoz/signoz/pkg/query-service/app/logparsingpipeline"
 	"github.com/SigNoz/signoz/pkg/query-service/interfaces"
@@ -96,7 +97,6 @@ func NewRouter() *mux.Router {
 
 // APIHandler implements the query service public API
 type APIHandler struct {
-	logger       *slog.Logger
 	reader       interfaces.Reader
 	ruleManager  *rules.Manager
 	querier      interfaces.Querier
@@ -212,7 +212,6 @@ func NewAPIHandler(opts APIHandlerOpts, config signoz.Config) (*APIHandler, erro
 	//quickFilterModule := quickfilter.NewAPI(opts.QuickFilterModule)
 
 	aH := &APIHandler{
-		logger:                        slog.Default(),
 		reader:                        opts.Reader,
 		temporalityMap:                make(map[string]map[v3.Temporality]bool),
 		ruleManager:                   opts.RuleManager,
@@ -252,13 +251,13 @@ func NewAPIHandler(opts APIHandlerOpts, config signoz.Config) (*APIHandler, erro
 	// TODO(nitya): remote this in later for multitenancy.
 	orgs, err := opts.Signoz.Modules.OrgGetter.ListByOwnedKeyRange(context.Background())
 	if err != nil {
-		aH.logger.Warn("unexpected error while fetching orgs while initializing base api handler", "error", err)
+		zap.L().Warn("unexpected error while fetching orgs  while initializing base api handler", zap.Error(err))
 	}
 	// if the first org with the first user is created then the setup is complete.
 	if len(orgs) == 1 {
 		count, err := opts.Signoz.Modules.UserGetter.CountByOrgID(context.Background(), orgs[0].ID)
 		if err != nil {
-			aH.logger.Warn("unexpected error while fetching user count while initializing base api handler", "error", err)
+			zap.L().Warn("unexpected error while fetch user count while initializing base api handler", zap.Error(err))
 		}
 
 		if count > 0 {
@@ -313,7 +312,7 @@ func RespondError(w http.ResponseWriter, apiErr model.BaseApiError, data interfa
 		Data:      data,
 	})
 	if err != nil {
-		slog.Error("error marshalling json response", "error", err)
+		zap.L().Error("error marshalling json response", zap.Error(err))
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
@@ -345,7 +344,7 @@ func RespondError(w http.ResponseWriter, apiErr model.BaseApiError, data interfa
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(code)
 	if n, err := w.Write(b); err != nil {
-		slog.Error("error writing response", "bytes_written", n, "error", err)
+		zap.L().Error("error writing response", zap.Int("bytesWritten", n), zap.Error(err))
 	}
 }
 
@@ -357,7 +356,7 @@ func writeHttpResponse(w http.ResponseWriter, data interface{}) {
 		Data:   data,
 	})
 	if err != nil {
-		slog.Error("error marshalling json response", "error", err)
+		zap.L().Error("error marshalling json response", zap.Error(err))
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
@@ -365,7 +364,7 @@ func writeHttpResponse(w http.ResponseWriter, data interface{}) {
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(http.StatusOK)
 	if n, err := w.Write(b); err != nil {
-		slog.Error("error writing response", "bytes_written", n, "error", err)
+		zap.L().Error("error writing response", zap.Int("bytesWritten", n), zap.Error(err))
 	}
 }
 
@@ -937,14 +936,14 @@ func (aH *APIHandler) metaForLinks(ctx context.Context, rule *ruletypes.Gettable
 			}
 			keys = model.GetLogFieldsV3(ctx, params, logFields)
 		} else {
-			aH.logger.ErrorContext(ctx, "failed to get log fields using empty keys", "error", apiErr)
+			zap.L().Error("failed to get log fields using empty keys; the link might not work as expected", zap.Error(apiErr))
 		}
 	} else if rule.AlertType == ruletypes.AlertTypeTraces {
 		traceFields, err := aH.reader.GetSpanAttributeKeysByNames(ctx, logsv3.GetFieldNames(rule.PostableRule.RuleCondition.CompositeQuery))
 		if err == nil {
 			keys = traceFields
 		} else {
-			aH.logger.ErrorContext(ctx, "failed to get span attributes using empty keys", "error", err)
+			zap.L().Error("failed to get span attributes using empty keys; the link might not work as expected", zap.Error(err))
 		}
 	}
 
@@ -1277,14 +1276,14 @@ func (aH *APIHandler) List(rw http.ResponseWriter, r *http.Request) {
 
 	installedIntegrationDashboards, apiErr := aH.IntegrationsController.GetDashboardsForInstalledIntegrations(ctx, orgID)
 	if apiErr != nil {
-		aH.logger.ErrorContext(ctx, "failed to get dashboards for installed integrations", "error", apiErr)
+		zap.L().Error("failed to get dashboards for installed integrations", zap.Error(apiErr))
 	} else {
 		dashboards = append(dashboards, installedIntegrationDashboards...)
 	}
 
 	cloudIntegrationDashboards, apiErr := aH.CloudIntegrationsController.AvailableDashboards(ctx, orgID)
 	if apiErr != nil {
-		aH.logger.ErrorContext(ctx, "failed to get dashboards for cloud integrations", "error", apiErr)
+		zap.L().Error("failed to get dashboards for cloud integrations", zap.Error(apiErr))
 	} else {
 		dashboards = append(dashboards, cloudIntegrationDashboards...)
 	}
@@ -1326,7 +1325,7 @@ func (aH *APIHandler) testRule(w http.ResponseWriter, r *http.Request) {
 	defer r.Body.Close()
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "error reading request body for test rule", "error", err)
+		zap.L().Error("Error in getting req body in test rule API", zap.Error(err))
 		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
 		return
 	}
@@ -1378,7 +1377,7 @@ func (aH *APIHandler) patchRule(w http.ResponseWriter, r *http.Request) {
 	defer r.Body.Close()
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "error reading request body for patch rule", "error", err)
+		zap.L().Error("error in getting req body of patch rule API\n", zap.Error(err))
 		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
 		return
 	}
@@ -1408,7 +1407,7 @@ func (aH *APIHandler) editRule(w http.ResponseWriter, r *http.Request) {
 	defer r.Body.Close()
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "error reading request body for edit rule", "error", err)
+		zap.L().Error("error in getting req body of edit rule API", zap.Error(err))
 		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
 		return
 	}
@@ -1433,7 +1432,7 @@ func (aH *APIHandler) createRule(w http.ResponseWriter, r *http.Request) {
 	defer r.Body.Close()
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "error reading request body for create rule", "error", err)
+		zap.L().Error("Error in getting req body for create rule API", zap.Error(err))
 		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
 		return
 	}
@@ -1457,7 +1456,7 @@ func (aH *APIHandler) queryRangeMetrics(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
-	// TODO: add structured logging for query and apiError if needed
+	// zap.L().Info(query, apiError)
 
 	ctx := r.Context()
 	if to := r.FormValue("timeout"); to != "" {
@@ -1479,7 +1478,7 @@ func (aH *APIHandler) queryRangeMetrics(w http.ResponseWriter, r *http.Request)
 	}
 
 	if res.Err != nil {
-		aH.logger.ErrorContext(r.Context(), "error in query range metrics", "error", res.Err)
+		zap.L().Error("error in query range metrics", zap.Error(res.Err))
 	}
 
 	if res.Err != nil {
@@ -1512,7 +1511,7 @@ func (aH *APIHandler) queryMetrics(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// TODO: add structured logging for query and apiError if needed
+	// zap.L().Info(query, apiError)
 
 	ctx := r.Context()
 	if to := r.FormValue("timeout"); to != "" {
@@ -1534,7 +1533,7 @@ func (aH *APIHandler) queryMetrics(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if res.Err != nil {
-		aH.logger.ErrorContext(r.Context(), "error in query range metrics", "error", res.Err)
+		zap.L().Error("error in query range metrics", zap.Error(res.Err))
 	}
 
 	if res.Err != nil {
@@ -1637,7 +1636,7 @@ func (aH *APIHandler) getServicesTopLevelOps(w http.ResponseWriter, r *http.Requ
 	var params topLevelOpsParams
 	err := json.NewDecoder(r.Body).Decode(&params)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "error reading request body for get top operations", "error", err)
+		zap.L().Error("Error in getting req body for get top operations API", zap.Error(err))
 	}
 
 	if params.Service != "" {
@@ -2059,7 +2058,7 @@ func (aH *APIHandler) HandleError(w http.ResponseWriter, err error, statusCode i
 		return false
 	}
 	if statusCode == http.StatusInternalServerError {
-		aH.logger.Error("internal server error in http handler", "error", err)
+		zap.L().Error("HTTP handler, Internal Server Error", zap.Error(err))
 	}
 	structuredResp := structuredResponse{
 		Errors: []structuredError{
@@ -2153,7 +2152,7 @@ func (aH *APIHandler) onboardProducers(
 ) {
 	messagingQueue, apiErr := ParseKafkaQueueBody(r)
 	if apiErr != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to parse kafka queue body", "error", apiErr.Err)
+		zap.L().Error(apiErr.Err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2161,7 +2160,7 @@ func (aH *APIHandler) onboardProducers(
 	chq, err := kafka.BuildClickHouseQuery(messagingQueue, kafka.KafkaQueue, "onboard_producers")
 
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build clickhouse query for onboard producers", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2255,7 +2254,7 @@ func (aH *APIHandler) onboardConsumers(
 ) {
 	messagingQueue, apiErr := ParseKafkaQueueBody(r)
 	if apiErr != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to parse kafka queue body", "error", apiErr.Err)
+		zap.L().Error(apiErr.Err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2263,7 +2262,7 @@ func (aH *APIHandler) onboardConsumers(
 	chq, err := kafka.BuildClickHouseQuery(messagingQueue, kafka.KafkaQueue, "onboard_consumers")
 
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build clickhouse query for onboard consumers", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2402,7 +2401,7 @@ func (aH *APIHandler) onboardKafka(w http.ResponseWriter, r *http.Request) {
 
 	messagingQueue, apiErr := ParseKafkaQueueBody(r)
 	if apiErr != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to parse kafka queue body", "error", apiErr.Err)
+		zap.L().Error(apiErr.Err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2410,7 +2409,7 @@ func (aH *APIHandler) onboardKafka(w http.ResponseWriter, r *http.Request) {
 	queryRangeParams, err := kafka.BuildBuilderQueriesKafkaOnboarding(messagingQueue)
 
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build kafka onboarding queries", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2512,19 +2511,19 @@ func (aH *APIHandler) getNetworkData(w http.ResponseWriter, r *http.Request) {
 	messagingQueue, apiErr := ParseKafkaQueueBody(r)
 
 	if apiErr != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to parse kafka queue body", "error", apiErr.Err)
+		zap.L().Error(apiErr.Err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
 
 	queryRangeParams, err := kafka.BuildQRParamsWithCache(messagingQueue, "throughput", attributeCache)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build query range params for throughput", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
 	if err := validateQueryRangeParamsV3(queryRangeParams); err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to validate query range params", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2563,12 +2562,12 @@ func (aH *APIHandler) getNetworkData(w http.ResponseWriter, r *http.Request) {
 
 	queryRangeParams, err = kafka.BuildQRParamsWithCache(messagingQueue, "fetch-latency", attributeCache)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build query range params for fetch latency", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
 	if err := validateQueryRangeParamsV3(queryRangeParams); err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to validate query range params for fetch latency", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2623,7 +2622,7 @@ func (aH *APIHandler) getProducerData(w http.ResponseWriter, r *http.Request) {
 	messagingQueue, apiErr := ParseKafkaQueueBody(r)
 
 	if apiErr != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to parse kafka queue body", "error", apiErr.Err)
+		zap.L().Error(apiErr.Err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2637,13 +2636,13 @@ func (aH *APIHandler) getProducerData(w http.ResponseWriter, r *http.Request) {
 
 	queryRangeParams, err := kafka.BuildQueryRangeParams(messagingQueue, "producer", kafkaSpanEval)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build query range params for producer", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
 
 	if err := validateQueryRangeParamsV3(queryRangeParams); err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to validate query range params for producer", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2680,7 +2679,7 @@ func (aH *APIHandler) getConsumerData(w http.ResponseWriter, r *http.Request) {
 	messagingQueue, apiErr := ParseKafkaQueueBody(r)
 
 	if apiErr != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to parse kafka queue body", "error", apiErr.Err)
+		zap.L().Error(apiErr.Err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2690,13 +2689,13 @@ func (aH *APIHandler) getConsumerData(w http.ResponseWriter, r *http.Request) {
 
 	queryRangeParams, err := kafka.BuildQueryRangeParams(messagingQueue, "consumer", kafkaSpanEval)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build query range params for consumer", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
 
 	if err := validateQueryRangeParamsV3(queryRangeParams); err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to validate query range params for consumer", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2738,7 +2737,7 @@ func (aH *APIHandler) getPartitionOverviewLatencyData(w http.ResponseWriter, r *
 	messagingQueue, apiErr := ParseKafkaQueueBody(r)
 
 	if apiErr != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to parse kafka queue body", "error", apiErr.Err)
+		zap.L().Error(apiErr.Err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2748,13 +2747,13 @@ func (aH *APIHandler) getPartitionOverviewLatencyData(w http.ResponseWriter, r *
 
 	queryRangeParams, err := kafka.BuildQueryRangeParams(messagingQueue, "producer-topic-throughput", kafkaSpanEval)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build query range params for producer topic throughput", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
 
 	if err := validateQueryRangeParamsV3(queryRangeParams); err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to validate query range params for producer topic throughput", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2796,7 +2795,7 @@ func (aH *APIHandler) getConsumerPartitionLatencyData(w http.ResponseWriter, r *
 	messagingQueue, apiErr := ParseKafkaQueueBody(r)
 
 	if apiErr != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to parse kafka queue body", "error", apiErr.Err)
+		zap.L().Error(apiErr.Err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2806,13 +2805,13 @@ func (aH *APIHandler) getConsumerPartitionLatencyData(w http.ResponseWriter, r *
 
 	queryRangeParams, err := kafka.BuildQueryRangeParams(messagingQueue, "consumer_partition_latency", kafkaSpanEval)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build query range params for consumer partition latency", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
 
 	if err := validateQueryRangeParamsV3(queryRangeParams); err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to validate query range params for consumer partition latency", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2856,7 +2855,7 @@ func (aH *APIHandler) getProducerThroughputOverview(w http.ResponseWriter, r *ht
 
 	messagingQueue, apiErr := ParseKafkaQueueBody(r)
 	if apiErr != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to parse kafka queue body", "error", apiErr.Err)
+		zap.L().Error(apiErr.Err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2867,13 +2866,13 @@ func (aH *APIHandler) getProducerThroughputOverview(w http.ResponseWriter, r *ht
 
 	producerQueryRangeParams, err := kafka.BuildQRParamsWithCache(messagingQueue, "producer-throughput-overview", attributeCache)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build query range params for producer throughput overview", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
 
 	if err := validateQueryRangeParamsV3(producerQueryRangeParams); err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to validate query range params for producer throughput overview", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2909,12 +2908,12 @@ func (aH *APIHandler) getProducerThroughputOverview(w http.ResponseWriter, r *ht
 
 	queryRangeParams, err := kafka.BuildQRParamsWithCache(messagingQueue, "producer-throughput-overview-byte-rate", attributeCache)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build query range params for producer throughput byte rate", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
 	if err := validateQueryRangeParamsV3(queryRangeParams); err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to validate query range params for producer throughput byte rate", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2972,7 +2971,7 @@ func (aH *APIHandler) getProducerThroughputDetails(w http.ResponseWriter, r *htt
 	messagingQueue, apiErr := ParseKafkaQueueBody(r)
 
 	if apiErr != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to parse kafka queue body", "error", apiErr.Err)
+		zap.L().Error(apiErr.Err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -2982,13 +2981,13 @@ func (aH *APIHandler) getProducerThroughputDetails(w http.ResponseWriter, r *htt
 
 	queryRangeParams, err := kafka.BuildQueryRangeParams(messagingQueue, "producer-throughput-details", kafkaSpanEval)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build query range params for producer throughput details", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
 
 	if err := validateQueryRangeParamsV3(queryRangeParams); err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to validate query range params for producer throughput details", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -3030,7 +3029,7 @@ func (aH *APIHandler) getConsumerThroughputOverview(w http.ResponseWriter, r *ht
 	messagingQueue, apiErr := ParseKafkaQueueBody(r)
 
 	if apiErr != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to parse kafka queue body", "error", apiErr.Err)
+		zap.L().Error(apiErr.Err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -3040,13 +3039,13 @@ func (aH *APIHandler) getConsumerThroughputOverview(w http.ResponseWriter, r *ht
 
 	queryRangeParams, err := kafka.BuildQueryRangeParams(messagingQueue, "consumer-throughput-overview", kafkaSpanEval)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build query range params for consumer throughput overview", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
 
 	if err := validateQueryRangeParamsV3(queryRangeParams); err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to validate query range params for consumer throughput overview", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -3088,7 +3087,7 @@ func (aH *APIHandler) getConsumerThroughputDetails(w http.ResponseWriter, r *htt
 	messagingQueue, apiErr := ParseKafkaQueueBody(r)
 
 	if apiErr != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to parse kafka queue body", "error", apiErr.Err)
+		zap.L().Error(apiErr.Err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -3098,13 +3097,13 @@ func (aH *APIHandler) getConsumerThroughputDetails(w http.ResponseWriter, r *htt
 
 	queryRangeParams, err := kafka.BuildQueryRangeParams(messagingQueue, "consumer-throughput-details", kafkaSpanEval)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build query range params for consumer throughput details", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
 
 	if err := validateQueryRangeParamsV3(queryRangeParams); err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to validate query range params for consumer throughput details", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -3149,7 +3148,7 @@ func (aH *APIHandler) getProducerConsumerEval(w http.ResponseWriter, r *http.Req
 	messagingQueue, apiErr := ParseKafkaQueueBody(r)
 
 	if apiErr != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to parse kafka queue body", "error", apiErr.Err)
+		zap.L().Error(apiErr.Err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -3159,7 +3158,7 @@ func (aH *APIHandler) getProducerConsumerEval(w http.ResponseWriter, r *http.Req
 
 	queryRangeParams, err := kafka.BuildQueryRangeParams(messagingQueue, "producer-consumer-eval", kafkaSpanEval)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build query range params for producer consumer eval", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, &model.ApiError{
 			Typ: model.ErrorBadData,
 			Err: err,
@@ -3168,7 +3167,7 @@ func (aH *APIHandler) getProducerConsumerEval(w http.ResponseWriter, r *http.Req
 	}
 
 	if err := validateQueryRangeParamsV3(queryRangeParams); err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to validate query range params for producer consumer eval", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -4256,7 +4255,7 @@ func (aH *APIHandler) CreateLogsPipeline(w http.ResponseWriter, r *http.Request)
 		postable []pipelinetypes.PostablePipeline,
 	) (*logparsingpipeline.PipelinesResponse, error) {
 		if len(postable) == 0 {
-			aH.logger.WarnContext(r.Context(), "found no pipelines in the http request, this will delete all the pipelines")
+			zap.L().Warn("found no pipelines in the http request, this will delete all the pipelines")
 		}
 
 		err := aH.LogsParsingPipelineController.ValidatePipelines(ctx, postable)
@@ -4454,7 +4453,7 @@ func (aH *APIHandler) QueryRangeV3Format(w http.ResponseWriter, r *http.Request)
 	queryRangeParams, apiErrorObj := ParseQueryRangeParams(r)
 
 	if apiErrorObj != nil {
-		aH.logger.ErrorContext(r.Context(), "error parsing query range params", "error", apiErrorObj.Err)
+		zap.L().Error(apiErrorObj.Err.Error())
 		RespondError(w, apiErrorObj, nil)
 		return
 	}
@@ -4516,13 +4515,13 @@ func (aH *APIHandler) queryRangeV3(ctx context.Context, queryRangeParams *v3.Que
 		// check if traceID is used as filter (with equal/similar operator) in traces query if yes add timestamp filter to queryRange params
 		isUsed, traceIDs := tracesV3.TraceIdFilterUsedWithEqual(queryRangeParams)
 		if isUsed && len(traceIDs) > 0 {
-			aH.logger.DebugContext(ctx, "trace_id used as filter in traces query")
+			zap.L().Debug("traceID used as filter in traces query")
 			// query signoz_spans table with traceID to get min and max timestamp
 			min, max, err := aH.reader.GetMinAndMaxTimestampForTraceID(ctx, traceIDs)
 			if err == nil {
 				// add timestamp filter to queryRange params
 				tracesV3.AddTimestampFilters(min, max, queryRangeParams)
-				aH.logger.DebugContext(ctx, "post adding timestamp filter in traces query", "query_range_params", queryRangeParams)
+				zap.L().Debug("post adding timestamp filter in traces query", zap.Any("queryRangeParams", queryRangeParams))
 			}
 		}
 	}
@@ -4533,8 +4532,9 @@ func (aH *APIHandler) queryRangeV3(ctx context.Context, queryRangeParams *v3.Que
 		onQueryFinished, apiErr := aH.reader.ReportQueryStartForProgressTracking(queryIdHeader)
 
 		if apiErr != nil {
-			aH.logger.ErrorContext(ctx, "failed to report query start for progress tracking",
-				"query_id", queryIdHeader, "error", apiErr,
+			zap.L().Error(
+				"couldn't report query start for progress tracking",
+				zap.String("queryId", queryIdHeader), zap.Error(apiErr),
 			)
 
 		} else {
@@ -4709,7 +4709,7 @@ func (aH *APIHandler) QueryRangeV3(w http.ResponseWriter, r *http.Request) {
 	queryRangeParams, apiErrorObj := ParseQueryRangeParams(r)
 
 	if apiErrorObj != nil {
-		aH.logger.ErrorContext(r.Context(), "error parsing metric query range params", "error", apiErrorObj.Err)
+		zap.L().Error("error parsing metric query range params", zap.Error(apiErrorObj.Err))
 		RespondError(w, apiErrorObj, nil)
 		return
 	}
@@ -4717,7 +4717,7 @@ func (aH *APIHandler) QueryRangeV3(w http.ResponseWriter, r *http.Request) {
 	// add temporality for each metric
 	temporalityErr := aH.PopulateTemporality(r.Context(), orgID, queryRangeParams)
 	if temporalityErr != nil {
-		aH.logger.ErrorContext(r.Context(), "error adding temporality for metrics", "error", temporalityErr)
+		zap.L().Error("Error while adding temporality for metrics", zap.Error(temporalityErr))
 		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: temporalityErr}, nil)
 		return
 	}
@@ -4761,8 +4761,9 @@ func (aH *APIHandler) GetQueryProgressUpdates(w http.ResponseWriter, r *http.Req
 	progressCh, unsubscribe, apiErr := aH.reader.SubscribeToQueryProgress(queryId)
 	if apiErr != nil {
 		// Shouldn't happen unless query progress requested after query finished
-		aH.logger.WarnContext(r.Context(), "failed to subscribe to query progress",
-			"query_id", queryId, "error", apiErr,
+		zap.L().Warn(
+			"couldn't subscribe to query progress",
+			zap.String("queryId", queryId), zap.Any("error", apiErr),
 		)
 		return
 	}
@@ -4771,22 +4772,25 @@ func (aH *APIHandler) GetQueryProgressUpdates(w http.ResponseWriter, r *http.Req
 	for queryProgress := range progressCh {
 		msg, err := json.Marshal(queryProgress)
 		if err != nil {
-			aH.logger.ErrorContext(r.Context(), "failed to serialize progress message",
-				"query_id", queryId, "progress", queryProgress, "error", err,
+			zap.L().Error(
+				"failed to serialize progress message",
+				zap.String("queryId", queryId), zap.Any("progress", queryProgress), zap.Error(err),
 			)
 			continue
 		}
 
 		err = c.WriteMessage(websocket.TextMessage, msg)
 		if err != nil {
-			aH.logger.ErrorContext(r.Context(), "failed to write progress message to websocket",
-				"query_id", queryId, "msg", string(msg), "error", err,
+			zap.L().Error(
+				"failed to write progress msg to websocket",
+				zap.String("queryId", queryId), zap.String("msg", string(msg)), zap.Error(err),
 			)
 			break
 
 		} else {
-			aH.logger.DebugContext(r.Context(), "wrote progress message to websocket",
-				"query_id", queryId, "msg", string(msg),
+			zap.L().Debug(
+				"wrote progress msg to websocket",
+				zap.String("queryId", queryId), zap.String("msg", string(msg)), zap.Error(err),
 			)
 		}
 	}
@@ -4870,13 +4874,13 @@ func (aH *APIHandler) queryRangeV4(ctx context.Context, queryRangeParams *v3.Que
 		// check if traceID is used as filter (with equal/similar operator) in traces query if yes add timestamp filter to queryRange params
 		isUsed, traceIDs := tracesV3.TraceIdFilterUsedWithEqual(queryRangeParams)
 		if isUsed && len(traceIDs) > 0 {
-			aH.logger.DebugContext(ctx, "trace_id used as filter in traces query")
+			zap.L().Debug("traceID used as filter in traces query")
 			// query signoz_spans table with traceID to get min and max timestamp
 			min, max, err := aH.reader.GetMinAndMaxTimestampForTraceID(ctx, traceIDs)
 			if err == nil {
 				// add timestamp filter to queryRange params
 				tracesV3.AddTimestampFilters(min, max, queryRangeParams)
-				aH.logger.DebugContext(ctx, "post adding timestamp filter in traces query", "query_range_params", queryRangeParams)
+				zap.L().Debug("post adding timestamp filter in traces query", zap.Any("queryRangeParams", queryRangeParams))
 			}
 		}
 	}
@@ -4928,7 +4932,7 @@ func (aH *APIHandler) QueryRangeV4(w http.ResponseWriter, r *http.Request) {
 	queryRangeParams, apiErrorObj := ParseQueryRangeParams(r)
 
 	if apiErrorObj != nil {
-		aH.logger.ErrorContext(r.Context(), "error parsing metric query range params", "error", apiErrorObj.Err)
+		zap.L().Error("error parsing metric query range params", zap.Error(apiErrorObj.Err))
 		RespondError(w, apiErrorObj, nil)
 		return
 	}
@@ -4937,7 +4941,7 @@ func (aH *APIHandler) QueryRangeV4(w http.ResponseWriter, r *http.Request) {
 	// add temporality for each metric
 	temporalityErr := aH.PopulateTemporality(r.Context(), orgID, queryRangeParams)
 	if temporalityErr != nil {
-		aH.logger.ErrorContext(r.Context(), "error adding temporality for metrics", "error", temporalityErr)
+		zap.L().Error("Error while adding temporality for metrics", zap.Error(temporalityErr))
 		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: temporalityErr}, nil)
 		return
 	}
@@ -4986,7 +4990,7 @@ func (aH *APIHandler) getQueueOverview(w http.ResponseWriter, r *http.Request) {
 	queueListRequest, apiErr := ParseQueueBody(r)
 
 	if apiErr != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to parse queue body", "error", apiErr.Err)
+		zap.L().Error(apiErr.Err.Error())
 		RespondError(w, apiErr, nil)
 		return
 	}
@@ -4994,7 +4998,7 @@ func (aH *APIHandler) getQueueOverview(w http.ResponseWriter, r *http.Request) {
 	chq, err := queues2.BuildOverviewQuery(queueListRequest)
 
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build queue overview query", "error", err)
+		zap.L().Error(err.Error())
 		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: fmt.Errorf("error building clickhouse query: %v", err)}, nil)
 		return
 	}
@@ -5025,7 +5029,7 @@ func (aH *APIHandler) getDomainList(w http.ResponseWriter, r *http.Request) {
 	// Parse the request body to get third-party query parameters
 	thirdPartyQueryRequest, apiErr := ParseRequestBody(r)
 	if apiErr != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to parse request body", "error", apiErr)
+		zap.L().Error("Failed to parse request body", zap.Error(apiErr))
 		render.Error(w, errorsV2.New(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, apiErr.Error()))
 		return
 	}
@@ -5033,7 +5037,7 @@ func (aH *APIHandler) getDomainList(w http.ResponseWriter, r *http.Request) {
 	// Build the v5 query range request for domain listing
 	queryRangeRequest, err := thirdpartyapi.BuildDomainList(thirdPartyQueryRequest)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build domain list query", "error", err)
+		zap.L().Error("Failed to build domain list query", zap.Error(err))
 		apiErrObj := errorsV2.New(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, err.Error())
 		render.Error(w, apiErrObj)
 		return
@@ -5046,7 +5050,7 @@ func (aH *APIHandler) getDomainList(w http.ResponseWriter, r *http.Request) {
 	// Execute the query using the v5 querier
 	result, err := aH.Signoz.Querier.QueryRange(ctx, orgID, queryRangeRequest)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "query execution failed", "error", err)
+		zap.L().Error("Query execution failed", zap.Error(err))
 		apiErrObj := errorsV2.New(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, err.Error())
 		render.Error(w, apiErrObj)
 		return
@@ -5085,7 +5089,7 @@ func (aH *APIHandler) getDomainInfo(w http.ResponseWriter, r *http.Request) {
 	// Parse the request body to get third-party query parameters
 	thirdPartyQueryRequest, apiErr := ParseRequestBody(r)
 	if apiErr != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to parse request body", "error", apiErr)
+		zap.L().Error("Failed to parse request body", zap.Error(apiErr))
 		render.Error(w, errorsV2.New(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, apiErr.Error()))
 		return
 	}
@@ -5093,7 +5097,7 @@ func (aH *APIHandler) getDomainInfo(w http.ResponseWriter, r *http.Request) {
 	// Build the v5 query range request for domain info
 	queryRangeRequest, err := thirdpartyapi.BuildDomainInfo(thirdPartyQueryRequest)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "failed to build domain info query", "error", err)
+		zap.L().Error("Failed to build domain info query", zap.Error(err))
 		apiErrObj := errorsV2.New(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, err.Error())
 		render.Error(w, apiErrObj)
 		return
@@ -5106,7 +5110,7 @@ func (aH *APIHandler) getDomainInfo(w http.ResponseWriter, r *http.Request) {
 	// Execute the query using the v5 querier
 	result, err := aH.Signoz.Querier.QueryRange(ctx, orgID, queryRangeRequest)
 	if err != nil {
-		aH.logger.ErrorContext(r.Context(), "query execution failed", "error", err)
+		zap.L().Error("Query execution failed", zap.Error(err))
 		apiErrObj := errorsV2.New(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, err.Error())
 		render.Error(w, apiErrObj)
 		return

pkg/query-service/app/inframetrics/hosts.go

@@ -17,10 +17,9 @@ import (
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	"github.com/SigNoz/signoz/pkg/query-service/postprocess"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
-	"log/slog"
-
 	"github.com/SigNoz/signoz/pkg/types/instrumentationtypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
+	"go.uber.org/zap"
 	"golang.org/x/exp/maps"
 	"golang.org/x/exp/slices"
 )
@@ -428,7 +427,7 @@ func (h *HostsRepo) GetHostList(ctx context.Context, orgID valuer.UUID, req mode
 
 	step := int64(math.Max(float64(common.MinAllowedStepInterval(req.Start, req.End)), 60))
 	if step <= 0 {
-		slog.ErrorContext(ctx, "step is less than or equal to 0", "step", step)
+		zap.L().Error("step is less than or equal to 0", zap.Int64("step", step))
 		return resp, errors.New("step is less than or equal to 0")
 	}
 

pkg/query-service/app/logparsingpipeline/collector_config.go

@@ -8,11 +8,10 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"log/slog"
-
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/query-service/constants"
 	"github.com/SigNoz/signoz/pkg/types/pipelinetypes"
+	"go.uber.org/zap"
 )
 
 var lockLogsPipelineSpec sync.RWMutex
@@ -155,14 +154,14 @@ func buildCollectorPipelineProcessorsList(
 
 func checkDuplicateString(pipeline []string) bool {
 	exists := make(map[string]bool, len(pipeline))
-	slog.Debug("checking duplicate processors in the pipeline", "pipeline", pipeline)
+	zap.L().Debug("checking duplicate processors in the pipeline:", zap.Any("pipeline", pipeline))
 	for _, processor := range pipeline {
 		name := processor
 		if _, ok := exists[name]; ok {
-			slog.Error(
+			zap.L().Error(
 				"duplicate processor name detected in generated collector config for log pipelines",
-				"processor", processor,
-				"pipeline", pipeline,
+				zap.String("processor", processor),
+				zap.Any("pipeline", pipeline),
 			)
 			return true
 		}

pkg/query-service/app/logparsingpipeline/controller.go

@@ -21,7 +21,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/google/uuid"
 
-	"log/slog"
+	"go.uber.org/zap"
 )
 
 var (
@@ -175,7 +175,7 @@ func (ic *LogParsingPipelineController) getEffectivePipelinesByVersion(
 	if version >= 0 {
 		savedPipelines, err := ic.getPipelinesByVersion(ctx, orgID.String(), version)
 		if err != nil {
-			slog.ErrorContext(ctx, "failed to get pipelines for version", "version", version, "error", err)
+			zap.L().Error("failed to get pipelines for version", zap.Int("version", version), zap.Error(err))
 			return nil, err
 		}
 		result = savedPipelines
@@ -227,7 +227,7 @@ func (ic *LogParsingPipelineController) GetPipelinesByVersion(
 ) (*PipelinesResponse, error) {
 	pipelines, err := ic.getEffectivePipelinesByVersion(ctx, orgId, version)
 	if err != nil {
-		slog.ErrorContext(ctx, "failed to get pipelines for version", "version", version, "error", err)
+		zap.L().Error("failed to get pipelines for version", zap.Int("version", version), zap.Error(err))
 		return nil, err
 	}
 
@@ -235,7 +235,7 @@ func (ic *LogParsingPipelineController) GetPipelinesByVersion(
 	if version >= 0 {
 		cv, err := agentConf.GetConfigVersion(ctx, orgId, opamptypes.ElementTypeLogPipelines, version)
 		if err != nil {
-			slog.ErrorContext(ctx, "failed to get config for version", "version", version, "error", err)
+			zap.L().Error("failed to get config for version", zap.Int("version", version), zap.Error(err))
 			return nil, err
 		}
 		configVersion = cv

pkg/query-service/app/logparsingpipeline/db.go

@@ -6,8 +6,6 @@ import (
 	"fmt"
 	"time"
 
-	"log/slog"
-
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
@@ -15,6 +13,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/types/pipelinetypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
+	"go.uber.org/zap"
 )
 
 // Repo handles DDL and DML ops on ingestion pipeline
@@ -81,7 +80,7 @@ func (r *Repo) insertPipeline(
 		Model(&insertRow.StoreablePipeline).
 		Exec(ctx)
 	if err != nil {
-		slog.ErrorContext(ctx, "error in inserting pipeline data", "error", err)
+		zap.L().Error("error in inserting pipeline data", zap.Error(err))
 		return nil, errors.WrapInternalf(err, errors.CodeInternal, "failed to insert pipeline")
 	}
 
@@ -137,12 +136,12 @@ func (r *Repo) GetPipeline(
 		Where("org_id = ?", orgID).
 		Scan(ctx)
 	if err != nil {
-		slog.ErrorContext(ctx, "failed to get ingestion pipeline from db", "error", err)
+		zap.L().Error("failed to get ingestion pipeline from db", zap.Error(err))
 		return nil, errors.WrapInternalf(err, errors.CodeInternal, "failed to get ingestion pipeline from db")
 	}
 
 	if len(storablePipelines) == 0 {
-		slog.WarnContext(ctx, "no row found for ingestion pipeline id", "id", id)
+		zap.L().Warn("No row found for ingestion pipeline id", zap.String("id", id))
 		return nil, errors.NewNotFoundf(errors.CodeNotFound, "no row found for ingestion pipeline id %v", id)
 	}
 
@@ -150,11 +149,11 @@ func (r *Repo) GetPipeline(
 		gettablePipeline := pipelinetypes.GettablePipeline{}
 		gettablePipeline.StoreablePipeline = storablePipelines[0]
 		if err := gettablePipeline.ParseRawConfig(); err != nil {
-			slog.ErrorContext(ctx, "invalid pipeline config found", "id", id, "error", err)
+			zap.L().Error("invalid pipeline config found", zap.String("id", id), zap.Error(err))
 			return nil, err
 		}
 		if err := gettablePipeline.ParseFilter(); err != nil {
-			slog.ErrorContext(ctx, "invalid pipeline filter found", "id", id, "error", err)
+			zap.L().Error("invalid pipeline filter found", zap.String("id", id), zap.Error(err))
 			return nil, err
 		}
 		return &gettablePipeline, nil

pkg/query-service/app/metrics/query_builder.go

@@ -2,12 +2,12 @@ package metrics
 
 import (
 	"fmt"
-	"log/slog"
 	"reflect"
 	"strconv"
 	"strings"
 
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
+	"go.uber.org/zap"
 )
 
 func AddMetricValueFilter(mq *v3.BuilderQuery) *v3.MetricValueFilter {
@@ -69,7 +69,7 @@ func AddMetricValueFilter(mq *v3.BuilderQuery) *v3.MetricValueFilter {
 				case string:
 					numericValue, err := strconv.ParseFloat(v, 64)
 					if err != nil {
-						slog.Warn("invalid type for metric value filter, ignoring", "type", reflect.TypeOf(v), "value", v)
+						zap.L().Warn("invalid type for metric value filter, ignoring", zap.Any("type", reflect.TypeOf(v)), zap.String("value", v))
 						continue
 					}
 					metricValueFilter = &v3.MetricValueFilter{
@@ -111,11 +111,11 @@ func FormattedValue(v interface{}) string {
 		case int, float32, float64, bool:
 			return strings.Join(strings.Fields(fmt.Sprint(x)), ",")
 		default:
-			slog.Error("invalid type for formatted value", "type", reflect.TypeOf(x[0]))
+			zap.L().Error("invalid type for formatted value", zap.Any("type", reflect.TypeOf(x[0])))
 			return ""
 		}
 	default:
-		slog.Error("invalid type for formatted value", "type", reflect.TypeOf(x))
+		zap.L().Error("invalid type for formatted value", zap.Any("type", reflect.TypeOf(x)))
 		return ""
 	}
 }
@@ -144,11 +144,11 @@ func PromFormattedValue(v interface{}) string {
 			}
 			return strings.Join(str, "|")
 		default:
-			slog.Error("invalid type for prom formatted value", "type", reflect.TypeOf(x[0]))
+			zap.L().Error("invalid type for prom formatted value", zap.Any("type", reflect.TypeOf(x[0])))
 			return ""
 		}
 	default:
-		slog.Error("invalid type for prom formatted value", "type", reflect.TypeOf(x))
+		zap.L().Error("invalid type for prom formatted value", zap.Any("type", reflect.TypeOf(x)))
 		return ""
 	}
 }

pkg/query-service/app/metricsexplorer/summary.go

@@ -8,7 +8,7 @@ import (
 	"strings"
 	"time"
 
-	"log/slog"
+	"go.uber.org/zap"
 
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/query-service/interfaces"
@@ -173,14 +173,14 @@ func (receiver *SummaryService) GetMetricsSummary(ctx context.Context, orgID val
 		if data != nil {
 			jsonData, err := json.Marshal(data)
 			if err != nil {
-				slog.Error("error marshalling data", "error", err)
+				zap.L().Error("Error marshalling data:", zap.Error(err))
 				return &model.ApiError{Typ: "MarshallingErr", Err: err}
 			}
 
 			var dashboards map[string][]metrics_explorer.Dashboard
 			err = json.Unmarshal(jsonData, &dashboards)
 			if err != nil {
-				slog.Error("error unmarshalling data", "error", err)
+				zap.L().Error("Error unmarshalling data:", zap.Error(err))
 				return &model.ApiError{Typ: "UnMarshallingErr", Err: err}
 			}
 			if _, ok := dashboards[metricName]; ok {
@@ -264,7 +264,7 @@ func (receiver *SummaryService) GetRelatedMetrics(ctx context.Context, params *m
 	if err != nil {
 		// If we hit a deadline exceeded error, proceed with only name similarity
 		if errors.Is(err.Err, context.DeadlineExceeded) {
-			slog.Warn("attribute similarity calculation timed out, proceeding with name similarity only")
+			zap.L().Warn("Attribute similarity calculation timed out, proceeding with name similarity only")
 			attrSimilarityScores = make(map[string]metrics_explorer.RelatedMetricsScore)
 		} else {
 			return nil, err
@@ -350,12 +350,12 @@ func (receiver *SummaryService) GetRelatedMetrics(ctx context.Context, params *m
 		if names != nil {
 			jsonData, err := json.Marshal(names)
 			if err != nil {
-				slog.Error("error marshalling dashboard data", "error", err)
+				zap.L().Error("Error marshalling dashboard data", zap.Error(err))
 				return &model.ApiError{Typ: "MarshallingErr", Err: err}
 			}
 			err = json.Unmarshal(jsonData, &dashboardsRelatedData)
 			if err != nil {
-				slog.Error("error unmarshalling dashboard data", "error", err)
+				zap.L().Error("Error unmarshalling dashboard data", zap.Error(err))
 				return &model.ApiError{Typ: "UnMarshallingErr", Err: err}
 			}
 		}

pkg/query-service/app/opamp/configure_ingestionRules.go

@@ -3,7 +3,6 @@ package opamp
 import (
 	"context"
 	"crypto/sha256"
-	"log/slog"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	model "github.com/SigNoz/signoz/pkg/query-service/app/opamp/model"
@@ -11,6 +10,7 @@ import (
 	"github.com/knadh/koanf/parsers/yaml"
 	"github.com/open-telemetry/opamp-go/protobufs"
 	"go.opentelemetry.io/collector/confmap"
+	"go.uber.org/zap"
 )
 
 var (
@@ -29,10 +29,10 @@ func UpsertControlProcessors(ctx context.Context, signal string,
 	// AddToTracePipeline() or RemoveFromTracesPipeline() prior to calling
 	// this method
 
-	slog.Debug("initiating ingestion rules deployment config", "signal", signal, "processors", processors)
+	zap.L().Debug("initiating ingestion rules deployment config", zap.String("signal", signal), zap.Any("processors", processors))
 
 	if signal != string(Metrics) && signal != string(Traces) {
-		slog.Error("received invalid signal in UpsertControlProcessors", "signal", signal)
+		zap.L().Error("received invalid signal int UpsertControlProcessors", zap.String("signal", signal))
 		return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "signal not supported in ingestion rules: %s", signal)
 	}
 
@@ -46,14 +46,14 @@ func UpsertControlProcessors(ctx context.Context, signal string,
 	}
 
 	if len(agents) > 1 && signal == string(Traces) {
-		slog.Debug("found multiple agents, this feature is not supported for traces pipeline (sampling rules)")
+		zap.L().Debug("found multiple agents. this feature is not supported for traces pipeline (sampling rules)")
 		return "", errors.NewInvalidInputf(CodeMultipleAgentsNotSupported, "multiple agents not supported in sampling rules")
 	}
 	hash := ""
 	for _, agent := range agents {
 		agenthash, err := addIngestionControlToAgent(agent, signal, processors, false)
 		if err != nil {
-			slog.Error("failed to push ingestion rules config to agent", "agent_id", agent.AgentID, "error", err)
+			zap.L().Error("failed to push ingestion rules config to agent", zap.String("agentID", agent.AgentID), zap.Error(err))
 			continue
 		}
 
@@ -82,7 +82,7 @@ func addIngestionControlToAgent(agent *model.Agent, signal string, processors ma
 	// add ingestion control spec
 	err = makeIngestionControlSpec(agentConf, Signal(signal), processors)
 	if err != nil {
-		slog.Error("failed to prepare ingestion control processors for agent", "agent_id", agent.AgentID, "error", err)
+		zap.L().Error("failed to prepare ingestion control processors for agent", zap.String("agentID", agent.AgentID), zap.Error(err))
 		return confHash, err
 	}
 
@@ -92,7 +92,7 @@ func addIngestionControlToAgent(agent *model.Agent, signal string, processors ma
 		return confHash, err
 	}
 
-	slog.Debug("sending new config", "config", string(configR))
+	zap.L().Debug("sending new config", zap.String("config", string(configR)))
 	hash := sha256.New()
 	_, err = hash.Write(configR)
 	if err != nil {
@@ -133,7 +133,7 @@ func makeIngestionControlSpec(agentConf *confmap.Conf, signal Signal, processors
 	// merge tracesPipelinePlan with current pipeline
 	mergedPipeline, err := buildPipeline(signal, currentPipeline)
 	if err != nil {
-		slog.Error("failed to build pipeline", "signal", string(signal), "error", err)
+		zap.L().Error("failed to build pipeline", zap.String("signal", string(signal)), zap.Error(err))
 		return err
 	}
 

pkg/query-service/app/opamp/model/agent.go

@@ -11,6 +11,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types/opamptypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
+	"go.uber.org/zap"
 	"google.golang.org/protobuf/proto"
 
 	"github.com/open-telemetry/opamp-go/protobufs"
@@ -304,7 +305,7 @@ func (agent *Agent) processStatusUpdate(
 func (agent *Agent) updateRemoteConfig(configProvider AgentConfigProvider) bool {
 	recommendedConfig, confId, err := configProvider.RecommendAgentConfig(agent.OrgID, []byte(agent.Config))
 	if err != nil {
-		agent.logger.Error("could not generate config recommendation for agent", "agent_id", agent.AgentID, "error", err)
+		zap.L().Error("could not generate config recommendation for agent", zap.String("agentID", agent.AgentID), zap.Error(err))
 		return false
 	}
 
@@ -321,7 +322,7 @@ func (agent *Agent) updateRemoteConfig(configProvider AgentConfigProvider) bool
 
 	if len(confId) < 1 {
 		// Should never happen. Handle gracefully if it does by some chance.
-		agent.logger.Error("config provider recommended a config with empty conf_id, using content hash for config_id")
+		zap.L().Error("config provider recommended a config with empty confId. Using content hash for configId")
 
 		hash := sha256.New()
 		for k, v := range cfg.Config.ConfigMap {

pkg/query-service/app/opamp/model/agents.go

@@ -14,6 +14,7 @@ import (
 	"github.com/open-telemetry/opamp-go/protobufs"
 	"github.com/open-telemetry/opamp-go/server/types"
 	"github.com/pkg/errors"
+	"go.uber.org/zap"
 )
 
 var AllAgents = Agents{
@@ -134,8 +135,8 @@ func (agents *Agents) RecommendLatestConfigToAll(
 
 		// Recommendation is same as current config
 		if string(newConfig) == agent.Config {
-			agents.logger.Info(
-				"recommended config same as current effective config for agent", "agent_id", agent.AgentID,
+			zap.L().Info(
+				"Recommended config same as current effective config for agent", zap.String("agentID", agent.AgentID),
 			)
 			return nil
 		}

pkg/query-service/app/opamp/opamp_server.go

@@ -2,7 +2,6 @@ package opamp
 
 import (
 	"context"
-	"log/slog"
 	"net/http"
 	"time"
 
@@ -12,6 +11,8 @@ import (
 	"github.com/open-telemetry/opamp-go/protobufs"
 	"github.com/open-telemetry/opamp-go/server"
 	"github.com/open-telemetry/opamp-go/server/types"
+
+	"go.uber.org/zap"
 )
 
 var opAmpServer *Server
@@ -19,7 +20,6 @@ var opAmpServer *Server
 type Server struct {
 	server server.OpAMPServer
 	agents *model.Agents
-	logger *slog.Logger
 
 	agentConfigProvider AgentConfigProvider
 
@@ -43,7 +43,6 @@ func InitializeServer(
 	opAmpServer = &Server{
 		agents:              agents,
 		agentConfigProvider: agentConfigProvider,
-		logger:              instrumentation.Logger(),
 	}
 	opAmpServer.server = server.New(wrappedLogger(instrumentation.Logger()))
 	return opAmpServer
@@ -71,8 +70,8 @@ func (srv *Server) Start(listener string) error {
 	unsubscribe := srv.agentConfigProvider.SubscribeToConfigUpdates(func() {
 		err := srv.agents.RecommendLatestConfigToAll(srv.agentConfigProvider)
 		if err != nil {
-			srv.logger.Error(
-				"could not roll out latest config recommendation to connected agents", "error", err,
+			zap.L().Error(
+				"could not roll out latest config recommendation to connected agents", zap.Error(err),
 			)
 		}
 	})
@@ -115,7 +114,7 @@ func (srv *Server) OnMessage(ctx context.Context, conn types.Connection, msg *pr
 	// agents sends the effective config when we processStatusUpdate.
 	agent, created, err := srv.agents.FindOrCreateAgent(agentID.String(), conn, orgID)
 	if err != nil {
-		srv.logger.Error("failed to find or create agent", "agent_id", agentID.String(), "error", err)
+		zap.L().Error("Failed to find or create agent", zap.String("agentID", agentID.String()), zap.Error(err))
 
 		// Return error response according to OpAMP protocol
 		return &protobufs.ServerToAgent{
@@ -135,10 +134,10 @@ func (srv *Server) OnMessage(ctx context.Context, conn types.Connection, msg *pr
 
 	if created {
 		agent.CanLB = model.ExtractLbFlag(msg.AgentDescription)
-		srv.logger.Debug(
-			"new agent added", "can_lb", agent.CanLB,
-			"agent_id", agent.AgentID,
-			"status", agent.Status,
+		zap.L().Debug(
+			"New agent added", zap.Bool("canLb", agent.CanLB),
+			zap.String("agentID", agent.AgentID),
+			zap.Any("status", agent.Status),
 		)
 	}
 
@@ -159,7 +158,7 @@ func Ready() bool {
 		return false
 	}
 	if opAmpServer.agents.Count() == 0 {
-		slog.Warn("no agents available, all agent config requests will be rejected")
+		zap.L().Warn("no agents available, all agent config requests will be rejected")
 		return false
 	}
 	return true

pkg/query-service/app/opamp/pipeline_builder.go

@@ -2,8 +2,9 @@ package opamp
 
 import (
 	"fmt"
-	"log/slog"
 	"sync"
+
+	"go.uber.org/zap"
 )
 
 var lockTracesPipelineSpec sync.RWMutex
@@ -88,7 +89,7 @@ func RemoveFromMetricsPipelineSpec(name string) {
 
 func checkDuplicates(pipeline []interface{}) bool {
 	exists := make(map[string]bool, len(pipeline))
-	slog.Debug("checking duplicate processors in the pipeline", "pipeline", pipeline)
+	zap.L().Debug("checking duplicate processors in the pipeline", zap.Any("pipeline", pipeline))
 	for _, processor := range pipeline {
 		name := processor.(string)
 		if _, ok := exists[name]; ok {
@@ -148,7 +149,7 @@ func buildPipeline(signal Signal, current []interface{}) ([]interface{}, error)
 			currentPos := loc + inserts
 			// if disabled then remove from the pipeline
 			if !m.Enabled {
-				slog.Debug("build_pipeline: found a disabled item, removing from pipeline at position", "position", currentPos-1, "processor", m.Name)
+				zap.L().Debug("build_pipeline: found a disabled item, removing from pipeline at position", zap.Int("position", currentPos-1), zap.String("processor", m.Name))
 				if currentPos-1 <= 0 {
 					pipeline = pipeline[currentPos+1:]
 				} else {
@@ -169,10 +170,10 @@ func buildPipeline(signal Signal, current []interface{}) ([]interface{}, error)
 				// right after last matched processsor (e.g. insert filters after tail_sampling for existing list of [batch, tail_sampling])
 
 				if lastMatched <= 0 {
-					slog.Debug("build_pipeline: found a new item to be inserted, inserting at position 0", "processor", m.Name)
+					zap.L().Debug("build_pipeline: found a new item to be inserted, inserting at position 0", zap.String("processor", m.Name))
 					pipeline = append([]interface{}{m.Name}, pipeline[lastMatched+1:]...)
 				} else {
-					slog.Debug("build_pipeline: found a new item to be inserted, inserting at position", "position", lastMatched, "processor", m.Name)
+					zap.L().Debug("build_pipeline: found a new item to be inserted, inserting at position", zap.Int("position", lastMatched), zap.String("processor", m.Name))
 					prior := make([]interface{}, len(pipeline[:lastMatched]))
 					next := make([]interface{}, len(pipeline[lastMatched:]))
 					copy(prior, pipeline[:lastMatched])

pkg/query-service/app/parser.go

@@ -19,11 +19,10 @@ import (
 	"github.com/SigNoz/govaluate"
 	"github.com/SigNoz/signoz/pkg/query-service/app/integrations/messagingQueues/kafka"
 	queues2 "github.com/SigNoz/signoz/pkg/query-service/app/integrations/messagingQueues/queues"
-	"log/slog"
-
 	"github.com/gorilla/mux"
 	promModel "github.com/prometheus/common/model"
 	"go.uber.org/multierr"
+	"go.uber.org/zap"
 
 	errorsV2 "github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/query-service/app/metrics"
@@ -741,9 +740,9 @@ func chTransformQuery(query string, variables map[string]interface{}) {
 	transformer := chVariables.NewQueryTransformer(query, varsForTransform)
 	transformedQuery, err := transformer.Transform()
 	if err != nil {
-		slog.Warn("failed to transform clickhouse query", "query", query, "error", err)
+		zap.L().Warn("failed to transform clickhouse query", zap.String("query", query), zap.Error(err))
 	}
-	slog.Info("transformed clickhouse query", "transformed_query", transformedQuery, "original_query", query)
+	zap.L().Info("transformed clickhouse query", zap.String("transformedQuery", transformedQuery), zap.String("originalQuery", query))
 }
 
 func ParseQueryRangeParams(r *http.Request) (*v3.QueryRangeParamsV3, *model.ApiError) {

pkg/query-service/app/querier/helper.go

@@ -15,6 +15,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/postprocess"
 	"github.com/SigNoz/signoz/pkg/query-service/querycache"
 	"github.com/SigNoz/signoz/pkg/valuer"
+	"go.uber.org/zap"
 )
 
 func prepareLogsQuery(
@@ -96,7 +97,7 @@ func (q *querier) runBuilderQuery(
 		var query string
 		var err error
 		if _, ok := cacheKeys[queryName]; !ok || params.NoCache {
-			q.logger.InfoContext(ctx, "skipping cache for logs query", "query_name", queryName, "start", start, "end", end, "step", builderQuery.StepInterval, "no_cache", params.NoCache, "cache_key", cacheKeys[queryName])
+			zap.L().Info("skipping cache for logs query", zap.String("queryName", queryName), zap.Int64("start", start), zap.Int64("end", end), zap.Int64("step", builderQuery.StepInterval), zap.Bool("noCache", params.NoCache), zap.String("cacheKey", cacheKeys[queryName]))
 			query, err = prepareLogsQuery(ctx, start, end, builderQuery, params)
 			if err != nil {
 				ch <- channelResult{Err: err, Name: queryName, Query: query, Series: nil}
@@ -108,7 +109,7 @@ func (q *querier) runBuilderQuery(
 		}
 
 		misses := q.queryCache.FindMissingTimeRanges(orgID, start, end, builderQuery.StepInterval, cacheKeys[queryName])
-		q.logger.InfoContext(ctx, "cache misses for logs query", "misses", misses)
+		zap.L().Info("cache misses for logs query", zap.Any("misses", misses))
 		missedSeries := make([]querycache.CachedSeriesData, 0)
 		filteredMissedSeries := make([]querycache.CachedSeriesData, 0)
 		for _, miss := range misses {
@@ -216,7 +217,7 @@ func (q *querier) runBuilderQuery(
 	// We are only caching the graph panel queries. A non-existant cache key means that the query is not cached.
 	// If the query is not cached, we execute the query and return the result without caching it.
 	if _, ok := cacheKeys[queryName]; !ok || params.NoCache {
-		q.logger.InfoContext(ctx, "skipping cache for metrics query", "query_name", queryName, "start", start, "end", end, "step", builderQuery.StepInterval, "no_cache", params.NoCache, "cache_key", cacheKeys[queryName])
+		zap.L().Info("skipping cache for metrics query", zap.String("queryName", queryName), zap.Int64("start", start), zap.Int64("end", end), zap.Int64("step", builderQuery.StepInterval), zap.Bool("noCache", params.NoCache), zap.String("cacheKey", cacheKeys[queryName]))
 		query, err := metricsV3.PrepareMetricQuery(start, end, params.CompositeQuery.QueryType, params.CompositeQuery.PanelType, builderQuery, metricsV3.Options{})
 		if err != nil {
 			ch <- channelResult{Err: err, Name: queryName, Query: query, Series: nil}
@@ -229,7 +230,7 @@ func (q *querier) runBuilderQuery(
 
 	cacheKey := cacheKeys[queryName]
 	misses := q.queryCache.FindMissingTimeRanges(orgID, start, end, builderQuery.StepInterval, cacheKey)
-	q.logger.InfoContext(ctx, "cache misses for metrics query", "misses", misses)
+	zap.L().Info("cache misses for metrics query", zap.Any("misses", misses))
 	missedSeries := make([]querycache.CachedSeriesData, 0)
 	for _, miss := range misses {
 		query, err := metricsV3.PrepareMetricQuery(
@@ -296,7 +297,7 @@ func (q *querier) runBuilderExpression(
 	}
 
 	if _, ok := cacheKeys[queryName]; !ok || params.NoCache {
-		q.logger.InfoContext(ctx, "skipping cache for expression query", "query_name", queryName, "start", params.Start, "end", params.End, "step", params.Step, "no_cache", params.NoCache, "cache_key", cacheKeys[queryName])
+		zap.L().Info("skipping cache for expression query", zap.String("queryName", queryName), zap.Int64("start", params.Start), zap.Int64("end", params.End), zap.Int64("step", params.Step), zap.Bool("noCache", params.NoCache), zap.String("cacheKey", cacheKeys[queryName]))
 		query := queries[queryName]
 		series, err := q.execClickHouseQuery(ctx, query)
 		ch <- channelResult{Err: err, Name: queryName, Query: query, Series: series}
@@ -306,7 +307,7 @@ func (q *querier) runBuilderExpression(
 	cacheKey := cacheKeys[queryName]
 	step := postprocess.StepIntervalForFunction(params, queryName)
 	misses := q.queryCache.FindMissingTimeRanges(orgID, params.Start, params.End, step, cacheKey)
-	q.logger.InfoContext(ctx, "cache misses for expression query", "misses", misses)
+	zap.L().Info("cache misses for expression query", zap.Any("misses", misses))
 	missedSeries := make([]querycache.CachedSeriesData, 0)
 	for _, miss := range misses {
 		missQueries, _ := q.builder.PrepareQueries(&v3.QueryRangeParamsV3{

pkg/query-service/app/querier/querier.go

@@ -18,13 +18,12 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/utils"
 	"github.com/SigNoz/signoz/pkg/valuer"
 
-	"log/slog"
-
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/query-service/interfaces"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	"go.uber.org/multierr"
+	"go.uber.org/zap"
 )
 
 type channelResult struct {
@@ -45,8 +44,6 @@ type querier struct {
 
 	builder *queryBuilder.QueryBuilder
 
-	logger *slog.Logger
-
 	// used for testing
 	// TODO(srikanthccv): remove this once we have a proper mock
 	testingMode     bool
@@ -88,8 +85,6 @@ func NewQuerier(opts QuerierOptions) interfaces.Querier {
 			BuildMetricQuery: metricsV3.PrepareMetricQuery,
 		}),
 
-		logger: slog.Default(),
-
 		testingMode:    opts.TestingMode,
 		returnedSeries: opts.ReturnedSeries,
 		returnedErr:    opts.ReturnedErr,
@@ -118,7 +113,7 @@ func (q *querier) execClickHouseQuery(ctx context.Context, query string) ([]*v3.
 		series.Points = points
 	}
 	if pointsWithNegativeTimestamps > 0 {
-		q.logger.ErrorContext(ctx, "found points with negative timestamps for query", "query", query)
+		zap.L().Error("found points with negative timestamps for query", zap.String("query", query))
 	}
 	return result, err
 }
@@ -211,14 +206,14 @@ func (q *querier) runPromQueries(ctx context.Context, orgID valuer.UUID, params
 			cacheKey, ok := cacheKeys[queryName]
 
 			if !ok || params.NoCache {
-				q.logger.InfoContext(ctx, "skipping cache for metrics prom query", "query_name", queryName, "start", params.Start, "end", params.End, "step", params.Step, "no_cache", params.NoCache, "cache_key", cacheKeys[queryName])
+				zap.L().Info("skipping cache for metrics prom query", zap.String("queryName", queryName), zap.Int64("start", params.Start), zap.Int64("end", params.End), zap.Int64("step", params.Step), zap.Bool("noCache", params.NoCache), zap.String("cacheKey", cacheKeys[queryName]))
 				query := metricsV3.BuildPromQuery(promQuery, params.Step, params.Start, params.End)
 				series, err := q.execPromQuery(ctx, query)
 				channelResults <- channelResult{Err: err, Name: queryName, Query: query.Query, Series: series}
 				return
 			}
 			misses := q.queryCache.FindMissingTimeRanges(orgID, params.Start, params.End, params.Step, cacheKey)
-			q.logger.InfoContext(ctx, "cache misses for metrics prom query", "misses", misses)
+			zap.L().Info("cache misses for metrics prom query", zap.Any("misses", misses))
 			missedSeries := make([]querycache.CachedSeriesData, 0)
 			for _, miss := range misses {
 				query := metricsV3.BuildPromQuery(promQuery, params.Step, miss.Start, miss.End)

pkg/query-service/app/querier/querier_test.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"math"
 	"strings"
-	"log/slog"
 	"testing"
 	"time"
 
@@ -1404,7 +1403,6 @@ func Test_querier_Traces_runWindowBasedListQueryDesc(t *testing.T) {
 
 			// Create reader and querier
 			reader := clickhouseReader.NewReader(
-				slog.Default(),
 				nil,
 				telemetryStore,
 				prometheustest.New(context.Background(), instrumentationtest.New().ToProviderSettings(), prometheus.Config{}, telemetryStore),
@@ -1630,7 +1628,6 @@ func Test_querier_Traces_runWindowBasedListQueryAsc(t *testing.T) {
 
 			// Create reader and querier
 			reader := clickhouseReader.NewReader(
-				slog.Default(),
 				nil,
 				telemetryStore,
 				prometheustest.New(context.Background(), instrumentationtest.New().ToProviderSettings(), prometheus.Config{}, telemetryStore),
@@ -1931,7 +1928,6 @@ func Test_querier_Logs_runWindowBasedListQueryDesc(t *testing.T) {
 
 			// Create reader and querier
 			reader := clickhouseReader.NewReader(
-				slog.Default(),
 				nil,
 				telemetryStore,
 				prometheustest.New(context.Background(), instrumentationtest.New().ToProviderSettings(), prometheus.Config{}, telemetryStore),
@@ -2159,7 +2155,6 @@ func Test_querier_Logs_runWindowBasedListQueryAsc(t *testing.T) {
 
 			// Create reader and querier
 			reader := clickhouseReader.NewReader(
-				slog.Default(),
 				nil,
 				telemetryStore,
 				prometheustest.New(context.Background(), instrumentationtest.New().ToProviderSettings(), prometheus.Config{}, telemetryStore),

pkg/query-service/app/querier/v2/helper.go

@@ -16,6 +16,7 @@ import (
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	"github.com/SigNoz/signoz/pkg/query-service/querycache"
 	"github.com/SigNoz/signoz/pkg/valuer"
+	"go.uber.org/zap"
 )
 
 func prepareLogsQuery(
@@ -98,7 +99,7 @@ func (q *querier) runBuilderQuery(
 		var query string
 		var err error
 		if _, ok := cacheKeys[queryName]; !ok || params.NoCache {
-			q.logger.InfoContext(ctx, "skipping cache for logs query", "query_name", queryName, "start", params.Start, "end", params.End, "step", params.Step, "no_cache", params.NoCache, "cache_key", cacheKeys[queryName])
+			zap.L().Info("skipping cache for logs query", zap.String("queryName", queryName), zap.Int64("start", params.Start), zap.Int64("end", params.End), zap.Int64("step", params.Step), zap.Bool("noCache", params.NoCache), zap.String("cacheKey", cacheKeys[queryName]))
 			query, err = prepareLogsQuery(ctx, start, end, builderQuery, params)
 			if err != nil {
 				ch <- channelResult{Err: err, Name: queryName, Query: query, Series: nil}
@@ -109,7 +110,7 @@ func (q *querier) runBuilderQuery(
 			return
 		}
 		misses := q.queryCache.FindMissingTimeRangesV2(orgID, start, end, builderQuery.StepInterval, cacheKeys[queryName])
-		q.logger.InfoContext(ctx, "cache misses for logs query", "misses", misses)
+		zap.L().Info("cache misses for logs query", zap.Any("misses", misses))
 		missedSeries := make([]querycache.CachedSeriesData, 0)
 		filteredMissedSeries := make([]querycache.CachedSeriesData, 0)
 		for _, miss := range misses {
@@ -218,7 +219,7 @@ func (q *querier) runBuilderQuery(
 	// We are only caching the graph panel queries. A non-existant cache key means that the query is not cached.
 	// If the query is not cached, we execute the query and return the result without caching it.
 	if _, ok := cacheKeys[queryName]; !ok || params.NoCache {
-		q.logger.InfoContext(ctx, "skipping cache for metrics query", "query_name", queryName, "start", params.Start, "end", params.End, "step", params.Step, "no_cache", params.NoCache, "cache_key", cacheKeys[queryName])
+		zap.L().Info("skipping cache for metrics query", zap.String("queryName", queryName), zap.Int64("start", params.Start), zap.Int64("end", params.End), zap.Int64("step", params.Step), zap.Bool("noCache", params.NoCache), zap.String("cacheKey", cacheKeys[queryName]))
 		query, err := metricsV4.PrepareMetricQuery(start, end, params.CompositeQuery.QueryType, params.CompositeQuery.PanelType, builderQuery, metricsV3.Options{})
 		if err != nil {
 			ch <- channelResult{Err: err, Name: queryName, Query: query, Series: nil}
@@ -230,7 +231,7 @@ func (q *querier) runBuilderQuery(
 	}
 
 	misses := q.queryCache.FindMissingTimeRanges(orgID, start, end, builderQuery.StepInterval, cacheKeys[queryName])
-	q.logger.InfoContext(ctx, "cache misses for metrics query", "misses", misses)
+	zap.L().Info("cache misses for metrics query", zap.Any("misses", misses))
 	missedSeries := make([]querycache.CachedSeriesData, 0)
 	for _, miss := range misses {
 		query, err := metricsV4.PrepareMetricQuery(
@@ -285,7 +286,7 @@ func (q *querier) ValidateMetricNames(ctx context.Context, query *v3.CompositeQu
 		for _, query := range query.PromQueries {
 			expr, err := parser.ParseExpr(query.Query)
 			if err != nil {
-				q.logger.DebugContext(ctx, "error parsing promql expression", "query", query.Query, "error", err)
+				zap.L().Debug("error parsing promQL expression", zap.String("query", query.Query), zap.Error(err))
 				continue
 			}
 			parser.Inspect(expr, func(node parser.Node, path []parser.Node) error {
@@ -301,14 +302,14 @@ func (q *querier) ValidateMetricNames(ctx context.Context, query *v3.CompositeQu
 		}
 		metrics, err := q.reader.GetNormalizedStatus(ctx, orgID, metricNames)
 		if err != nil {
-			q.logger.DebugContext(ctx, "error getting corresponding normalized metrics", "error", err)
+			zap.L().Debug("error getting corresponding normalized metrics", zap.Error(err))
 			return
 		}
 		for metricName, metricPresent := range metrics {
 			if metricPresent {
 				continue
 			} else {
-				q.logger.WarnContext(ctx, "using normalized metric name", "metrics", metricName)
+				zap.L().Warn("using normalized metric name", zap.String("metrics", metricName))
 				continue
 			}
 		}
@@ -319,14 +320,14 @@ func (q *querier) ValidateMetricNames(ctx context.Context, query *v3.CompositeQu
 		}
 		metrics, err := q.reader.GetNormalizedStatus(ctx, orgID, metricNames)
 		if err != nil {
-			q.logger.DebugContext(ctx, "error getting corresponding normalized metrics", "error", err)
+			zap.L().Debug("error getting corresponding normalized metrics", zap.Error(err))
 			return
 		}
 		for metricName, metricPresent := range metrics {
 			if metricPresent {
 				continue
 			} else {
-				q.logger.WarnContext(ctx, "using normalized metric name", "metrics", metricName)
+				zap.L().Warn("using normalized metric name", zap.String("metrics", metricName))
 				continue
 			}
 		}

pkg/query-service/app/querier/v2/querier.go

@@ -18,13 +18,12 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/utils"
 	"github.com/SigNoz/signoz/pkg/valuer"
 
-	"log/slog"
-
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/query-service/interfaces"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	"go.uber.org/multierr"
+	"go.uber.org/zap"
 )
 
 type channelResult struct {
@@ -45,8 +44,6 @@ type querier struct {
 
 	builder *queryBuilder.QueryBuilder
 
-	logger *slog.Logger
-
 	// used for testing
 	// TODO(srikanthccv): remove this once we have a proper mock
 	testingMode     bool
@@ -88,8 +85,6 @@ func NewQuerier(opts QuerierOptions) interfaces.Querier {
 			BuildMetricQuery: metricsV4.PrepareMetricQuery,
 		}),
 
-		logger: slog.Default(),
-
 		testingMode:    opts.TestingMode,
 		returnedSeries: opts.ReturnedSeries,
 		returnedErr:    opts.ReturnedErr,
@@ -120,7 +115,7 @@ func (q *querier) execClickHouseQuery(ctx context.Context, query string) ([]*v3.
 		series.Points = points
 	}
 	if pointsWithNegativeTimestamps > 0 {
-		q.logger.ErrorContext(ctx, "found points with negative timestamps for query", "query", query)
+		zap.L().Error("found points with negative timestamps for query", zap.String("query", query))
 	}
 	return result, err
 }
@@ -172,7 +167,7 @@ func (q *querier) runBuilderQueries(ctx context.Context, orgID valuer.UUID, para
 
 	wg.Wait()
 	close(ch)
-	q.logger.InfoContext(ctx, "time taken to run builder queries", "multi_query_duration", time.Since(now), "num_queries", len(params.CompositeQuery.BuilderQueries))
+	zap.L().Info("time taken to run builder queries", zap.Duration("multiQueryDuration", time.Since(now)), zap.Int("num_queries", len(params.CompositeQuery.BuilderQueries)))
 
 	results := make([]*v3.Result, 0)
 	errQueriesByName := make(map[string]error)
@@ -213,14 +208,14 @@ func (q *querier) runPromQueries(ctx context.Context, orgID valuer.UUID, params
 			cacheKey, ok := cacheKeys[queryName]
 
 			if !ok || params.NoCache {
-				q.logger.InfoContext(ctx, "skipping cache for metrics prom query", "query_name", queryName, "start", params.Start, "end", params.End, "step", params.Step, "no_cache", params.NoCache, "cache_key", cacheKeys[queryName])
+				zap.L().Info("skipping cache for metrics prom query", zap.String("queryName", queryName), zap.Int64("start", params.Start), zap.Int64("end", params.End), zap.Int64("step", params.Step), zap.Bool("noCache", params.NoCache), zap.String("cacheKey", cacheKeys[queryName]))
 				query := metricsV4.BuildPromQuery(promQuery, params.Step, params.Start, params.End)
 				series, err := q.execPromQuery(ctx, query)
 				channelResults <- channelResult{Err: err, Name: queryName, Query: query.Query, Series: series}
 				return
 			}
 			misses := q.queryCache.FindMissingTimeRanges(orgID, params.Start, params.End, params.Step, cacheKey)
-			q.logger.InfoContext(ctx, "cache misses for metrics prom query", "misses", misses)
+			zap.L().Info("cache misses for metrics prom query", zap.Any("misses", misses))
 			missedSeries := make([]querycache.CachedSeriesData, 0)
 			for _, miss := range misses {
 				query := metricsV4.BuildPromQuery(promQuery, params.Step, miss.Start, miss.End)

pkg/query-service/app/querier/v2/querier_test.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"math"
 	"strings"
-	"log/slog"
 	"testing"
 	"time"
 
@@ -1456,7 +1455,6 @@ func Test_querier_Traces_runWindowBasedListQueryDesc(t *testing.T) {
 
 			// Create reader and querier
 			reader := clickhouseReader.NewReader(
-				slog.Default(),
 				nil,
 				telemetryStore,
 				prometheustest.New(context.Background(), instrumentationtest.New().ToProviderSettings(), prometheus.Config{}, telemetryStore),
@@ -1682,7 +1680,6 @@ func Test_querier_Traces_runWindowBasedListQueryAsc(t *testing.T) {
 
 			// Create reader and querier
 			reader := clickhouseReader.NewReader(
-				slog.Default(),
 				nil,
 				telemetryStore,
 				prometheustest.New(context.Background(), instrumentationtest.New().ToProviderSettings(), prometheus.Config{}, telemetryStore),
@@ -1982,7 +1979,6 @@ func Test_querier_Logs_runWindowBasedListQueryDesc(t *testing.T) {
 
 			// Create reader and querier
 			reader := clickhouseReader.NewReader(
-				slog.Default(),
 				nil,
 				telemetryStore,
 				prometheustest.New(context.Background(), instrumentationtest.New().ToProviderSettings(), prometheus.Config{}, telemetryStore),
@@ -2210,7 +2206,6 @@ func Test_querier_Logs_runWindowBasedListQueryAsc(t *testing.T) {
 
 			// Create reader and querier
 			reader := clickhouseReader.NewReader(
-				slog.Default(),
 				nil,
 				telemetryStore,
 				prometheustest.New(context.Background(), instrumentationtest.New().ToProviderSettings(), prometheus.Config{}, telemetryStore),

pkg/query-service/app/queryBuilder/query_builder.go

@@ -4,13 +4,12 @@ import (
 	"fmt"
 	"strings"
 
-	"log/slog"
-
 	"github.com/SigNoz/govaluate"
 	"github.com/SigNoz/signoz/pkg/cache"
 	metricsV3 "github.com/SigNoz/signoz/pkg/query-service/app/metrics/v3"
 	"github.com/SigNoz/signoz/pkg/query-service/constants"
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
+	"go.uber.org/zap"
 )
 
 var SupportedFunctions = []string{
@@ -239,7 +238,7 @@ func (qb *QueryBuilder) PrepareQueries(params *v3.QueryRangeParamsV3) (map[strin
 					}
 					queries[queryName] = queryString
 				default:
-					slog.Error("unknown data source", "data_source", string(query.DataSource))
+					zap.L().Error("Unknown data source", zap.String("dataSource", string(query.DataSource)))
 				}
 			}
 		}