ui: fix double metric selection in list

Signed-off-by: rjshrjndrn <rjshrjndrn@gmail.com>

.github/workflows/assist-server-ee.yaml

@@ -0,0 +1,122 @@
+# This action will push the assist changes to aws
+on:
+  workflow_dispatch:
+    inputs:
+      skip_security_checks:
+        description: "Skip Security checks if there is a unfixable vuln or error. Value: true/false"
+        required: false
+        default: "false"
+  push:
+    branches:
+      - dev
+    paths:
+      - "ee/assist-server/**"
+
+name: Build and Deploy Assist-Server EE
+
+jobs:
+  deploy:
+    name: Deploy
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          # We need to diff with old commit
+          # to see which workers got changed.
+          fetch-depth: 2
+
+      - uses: ./.github/composite-actions/update-keys
+        with:
+          assist_jwt_secret: ${{ secrets.ASSIST_JWT_SECRET }}
+          assist_key: ${{ secrets.ASSIST_KEY }}
+          domain_name: ${{ secrets.EE_DOMAIN_NAME }}
+          jwt_refresh_secret: ${{ secrets.JWT_REFRESH_SECRET }}
+          jwt_secret: ${{ secrets.EE_JWT_SECRET }}
+          jwt_spot_refresh_secret: ${{ secrets.JWT_SPOT_REFRESH_SECRET }}
+          jwt_spot_secret: ${{ secrets.JWT_SPOT_SECRET }}
+          license_key: ${{ secrets.EE_LICENSE_KEY }}
+          minio_access_key: ${{ secrets.EE_MINIO_ACCESS_KEY }}
+          minio_secret_key: ${{ secrets.EE_MINIO_SECRET_KEY }}
+          pg_password: ${{ secrets.EE_PG_PASSWORD }}
+          registry_url: ${{ secrets.OSS_REGISTRY_URL }}
+        name: Update Keys
+
+      - name: Docker login
+        run: |
+          docker login ${{ secrets.EE_REGISTRY_URL }} -u ${{ secrets.EE_DOCKER_USERNAME }} -p "${{ secrets.EE_REGISTRY_TOKEN }}"
+
+      - uses: azure/k8s-set-context@v1
+        with:
+          method: kubeconfig
+          kubeconfig: ${{ secrets.EE_KUBECONFIG }} # Use content of kubeconfig in secret.
+        id: setcontext
+
+      - name: Building and Pushing Assist-Server image
+        id: build-image
+        env:
+          DOCKER_REPO: ${{ secrets.EE_REGISTRY_URL }}
+          IMAGE_TAG: ${{ github.ref_name }}_${{ github.sha }}-ee
+          ENVIRONMENT: staging
+        run: |
+          skip_security_checks=${{ github.event.inputs.skip_security_checks }}
+          cd assist-server
+          PUSH_IMAGE=0 bash -x ./build.sh ee
+          [[ "x$skip_security_checks" == "xtrue" ]]  || {
+            curl -L https://github.com/aquasecurity/trivy/releases/download/v0.56.2/trivy_0.56.2_Linux-64bit.tar.gz | tar -xzf - -C ./ 
+            images=("assist-server")
+            for image in ${images[*]};do
+              ./trivy image --db-repository ghcr.io/aquasecurity/trivy-db:2 --db-repository public.ecr.aws/aquasecurity/trivy-db:2 --exit-code 1 --security-checks vuln --vuln-type os,library --severity "HIGH,CRITICAL"  --ignore-unfixed $DOCKER_REPO/$image:$IMAGE_TAG 
+            done
+            err_code=$?
+            [[ $err_code -ne 0 ]] && {
+              exit $err_code
+            }
+          } && {
+            echo "Skipping Security Checks"
+          }
+          images=("assist-server")
+          for image in ${images[*]};do
+            docker push $DOCKER_REPO/$image:$IMAGE_TAG 
+          done
+      - name: Creating old image input
+        run: |
+          #
+          # Create yaml with existing image tags
+          #
+          kubectl get pods -n app -o jsonpath="{.items[*].spec.containers[*].image}" |\
+          tr -s '[[:space:]]' '\n' | sort | uniq -c | grep '/foss/' | cut -d '/' -f3 > /tmp/image_tag.txt
+
+          echo > /tmp/image_override.yaml
+
+          for line in `cat /tmp/image_tag.txt`;
+          do
+              image_array=($(echo "$line" | tr ':' '\n'))
+              cat <<EOF >> /tmp/image_override.yaml
+          ${image_array[0]}:
+            image:
+              # We've to strip off the -ee, as helm will append it.
+              tag: `echo ${image_array[1]} | cut -d '-' -f 1`
+          EOF
+          done
+      - name: Deploy to kubernetes
+        run: |
+          pwd
+          cd scripts/helmcharts/
+
+          # Update changed image tag
+          sed -i "/assist-server/{n;n;n;s/.*/    tag: ${IMAGE_TAG}/}" /tmp/image_override.yaml
+
+          cat /tmp/image_override.yaml
+          # Deploy command
+          mkdir -p /tmp/charts
+          mv openreplay/charts/{ingress-nginx,assist-server,quickwit,connector} /tmp/charts/
+          rm -rf  openreplay/charts/*
+          mv /tmp/charts/* openreplay/charts/
+          helm template openreplay -n app openreplay -f vars.yaml -f /tmp/image_override.yaml --set ingress-nginx.enabled=false --set skipMigration=true --no-hooks --kube-version=$k_version | kubectl apply -f -
+        env:
+          DOCKER_REPO: ${{ secrets.EE_REGISTRY_URL }}
+          # We're not passing -ee flag, because helm will add that.
+          IMAGE_TAG: ${{ github.ref_name }}_${{ github.sha }}
+          ENVIRONMENT: staging

.github/workflows/patch-build-old.yaml

@@ -0,0 +1,189 @@
+# Ref: https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions
+
+on:
+  workflow_dispatch:
+    inputs:
+      services:
+        description: 'Comma separated names of services to build(in small letters).'
+        required: true
+        default: 'chalice,frontend'
+      tag:
+        description: 'Tag to update.'
+        required: true
+        type: string
+      branch:
+        description: 'Branch to build patches from. Make sure the branch is uptodate with tag. Else itll cause missing commits.'
+        required: true
+        type: string
+
+name: Build patches from tag, rewrite commit HEAD to older timestamp, and Push the tag
+
+jobs:
+  deploy:
+    name: Build Patch from old tag
+    runs-on: ubuntu-latest
+    env:
+      DEPOT_TOKEN: ${{ secrets.DEPOT_TOKEN }}
+      DEPOT_PROJECT_ID: ${{ secrets.DEPOT_PROJECT_ID }}
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+      with:
+        fetch-depth: 4
+        ref: ${{ github.event.inputs.tag }}
+
+    - name: Set Remote with GITHUB_TOKEN
+      run: |
+        git config --unset http.https://github.com/.extraheader
+        git remote set-url origin https://x-access-token:${{ secrets.ACTIONS_COMMMIT_TOKEN }}@github.com/${{ github.repository }}.git
+
+    - name: Create backup tag with timestamp
+      run: |
+        set -e  # Exit immediately if a command exits with a non-zero status
+        TIMESTAMP=$(date +%Y%m%d%H%M%S)
+        BACKUP_TAG="${{ github.event.inputs.tag }}-backup-${TIMESTAMP}"
+        echo "BACKUP_TAG=${BACKUP_TAG}" >> $GITHUB_ENV
+        echo "INPUT_TAG=${{ github.event.inputs.tag }}" >> $GITHUB_ENV
+        git tag $BACKUP_TAG || { echo "Failed to create backup tag"; exit 1; }
+        git push origin $BACKUP_TAG || { echo "Failed to push backup tag"; exit 1; }
+        echo "Created backup tag: $BACKUP_TAG"
+
+        # Get the oldest commit date from the last 3 commits in raw format
+        OLDEST_COMMIT_TIMESTAMP=$(git log -3 --pretty=format:"%at" | tail -1)
+        echo "Oldest commit timestamp: $OLDEST_COMMIT_TIMESTAMP"
+        # Add 1 second to the timestamp
+        NEW_TIMESTAMP=$((OLDEST_COMMIT_TIMESTAMP + 1))
+        echo "NEW_TIMESTAMP=$NEW_TIMESTAMP" >> $GITHUB_ENV
+
+
+    - name: Setup yq
+      uses: mikefarah/yq@master
+
+    # Configure AWS credentials for the first registry
+    - name: Configure AWS credentials for RELEASE_ARM_REGISTRY
+      uses: aws-actions/configure-aws-credentials@v1
+      with:
+        aws-access-key-id: ${{ secrets.AWS_DEPOT_ACCESS_KEY }}
+        aws-secret-access-key: ${{ secrets.AWS_DEPOT_SECRET_KEY }}
+        aws-region: ${{ secrets.AWS_DEPOT_DEFAULT_REGION }}
+
+    - name: Login to Amazon ECR for RELEASE_ARM_REGISTRY
+      id: login-ecr-arm
+      run: |
+        aws ecr get-login-password --region ${{ secrets.AWS_DEPOT_DEFAULT_REGION }} | docker login --username AWS --password-stdin ${{ secrets.RELEASE_ARM_REGISTRY }}
+        aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin ${{ secrets.RELEASE_OSS_REGISTRY }}
+
+    - uses: depot/setup-action@v1
+    - name: Get HEAD Commit ID
+      run: echo "HEAD_COMMIT_ID=$(git rev-parse HEAD)" >> $GITHUB_ENV
+    - name: Define Branch Name
+      run: echo "BRANCH_NAME=${{inputs.branch}}" >> $GITHUB_ENV
+
+    - name: Build
+      id: build-image
+      env:
+        DOCKER_REPO_ARM: ${{ secrets.RELEASE_ARM_REGISTRY }}
+        DOCKER_REPO_OSS: ${{ secrets.RELEASE_OSS_REGISTRY }}
+        MSAAS_REPO_CLONE_TOKEN: ${{ secrets.MSAAS_REPO_CLONE_TOKEN }}
+        MSAAS_REPO_URL: ${{ secrets.MSAAS_REPO_URL }}
+        MSAAS_REPO_FOLDER: /tmp/msaas
+      run: |
+        set -exo pipefail
+        git config --local user.email "action@github.com"
+        git config --local user.name "GitHub Action"
+        git checkout -b $BRANCH_NAME
+        working_dir=$(pwd)
+        function image_version(){
+          local service=$1
+          chart_path="$working_dir/scripts/helmcharts/openreplay/charts/$service/Chart.yaml"
+          current_version=$(yq eval '.AppVersion' $chart_path)
+          new_version=$(echo $current_version | awk -F. '{$NF += 1 ; print $1"."$2"."$3}')
+          echo $new_version
+          # yq eval ".AppVersion = \"$new_version\"" -i $chart_path
+        }
+        function clone_msaas() {
+          [ -d $MSAAS_REPO_FOLDER ] || {
+          git clone -b $INPUT_TAG --recursive https://x-access-token:$MSAAS_REPO_CLONE_TOKEN@$MSAAS_REPO_URL $MSAAS_REPO_FOLDER
+          cd $MSAAS_REPO_FOLDER
+          cd openreplay && git fetch origin && git checkout $INPUT_TAG
+          git log -1
+          cd $MSAAS_REPO_FOLDER
+          bash git-init.sh
+          git checkout
+          }
+        }
+        function build_managed() {
+          local service=$1
+          local version=$2
+          echo building managed
+          clone_msaas
+          if [[ $service == 'chalice' ]]; then
+            cd $MSAAS_REPO_FOLDER/openreplay/api
+          else
+            cd $MSAAS_REPO_FOLDER/openreplay/$service
+          fi
+          IMAGE_TAG=$version DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=arm64 DOCKER_REPO=$DOCKER_REPO_ARM PUSH_IMAGE=0 bash build.sh >> /tmp/arm.txt
+        }
+        # Checking for backend images
+        ls backend/cmd >> /tmp/backend.txt
+        echo Services: "${{ github.event.inputs.services }}"
+        IFS=',' read -ra SERVICES <<< "${{ github.event.inputs.services }}" 
+        BUILD_SCRIPT_NAME="build.sh"
+        # Build FOSS
+        for SERVICE in "${SERVICES[@]}"; do
+          # Check if service is backend
+          if grep -q $SERVICE /tmp/backend.txt; then 
+            cd backend 
+            foss_build_args="nil $SERVICE"
+            ee_build_args="ee $SERVICE"
+          else 
+            [[ $SERVICE == 'chalice' || $SERVICE == 'alerts' || $SERVICE == 'crons' ]] && cd $working_dir/api || cd $SERVICE
+            [[ $SERVICE == 'alerts' || $SERVICE == 'crons' ]] && BUILD_SCRIPT_NAME="build_${SERVICE}.sh"
+            ee_build_args="ee"
+          fi  
+          version=$(image_version $SERVICE)
+          echo IMAGE_TAG=$version DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=amd64 DOCKER_REPO=$DOCKER_REPO_OSS PUSH_IMAGE=0 bash ${BUILD_SCRIPT_NAME} $foss_build_args
+          IMAGE_TAG=$version DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=amd64 DOCKER_REPO=$DOCKER_REPO_OSS PUSH_IMAGE=0 bash ${BUILD_SCRIPT_NAME} $foss_build_args
+          echo IMAGE_TAG=$version-ee DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=amd64 DOCKER_REPO=$DOCKER_REPO_OSS PUSH_IMAGE=0 bash ${BUILD_SCRIPT_NAME} $ee_build_args
+          IMAGE_TAG=$version-ee DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=amd64 DOCKER_REPO=$DOCKER_REPO_OSS PUSH_IMAGE=0 bash ${BUILD_SCRIPT_NAME} $ee_build_args
+          if [[ "$SERVICE" != "chalice" && "$SERVICE" != "frontend" ]]; then
+            IMAGE_TAG=$version DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=arm64 DOCKER_REPO=$DOCKER_REPO_ARM PUSH_IMAGE=0 bash ${BUILD_SCRIPT_NAME} $foss_build_args
+            echo IMAGE_TAG=$version DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=arm64 DOCKER_REPO=$DOCKER_REPO_ARM PUSH_IMAGE=0 bash ${BUILD_SCRIPT_NAME} $foss_build_args
+          else
+            build_managed $SERVICE $version
+          fi
+          cd $working_dir
+          chart_path="$working_dir/scripts/helmcharts/openreplay/charts/$SERVICE/Chart.yaml"
+          yq eval ".AppVersion = \"$version\"" -i $chart_path
+          git add $chart_path
+          git commit -m "Increment $SERVICE chart version"
+        done
+
+    - name: Change commit timestamp
+      run: |
+        # Convert the timestamp to a date format git can understand
+        NEW_DATE=$(perl -le 'print scalar gmtime($ARGV[0])." +0000"' $NEW_TIMESTAMP)
+        echo "Setting commit date to: $NEW_DATE"
+
+        # Amend the commit with the new date
+        GIT_COMMITTER_DATE="$NEW_DATE" git commit --amend --no-edit --date="$NEW_DATE"
+
+        # Verify the change
+        git log -1 --pretty=format:"Commit now dated: %cD"
+
+        # git tag and push
+        git tag $INPUT_TAG -f
+        git push origin $INPUT_TAG -f
+
+
+    # - name: Debug Job
+    #   if: ${{ failure() }}
+    #   uses: mxschmitt/action-tmate@v3
+    #   env:
+    #     DOCKER_REPO_ARM: ${{ secrets.RELEASE_ARM_REGISTRY }}
+    #     DOCKER_REPO_OSS: ${{ secrets.RELEASE_OSS_REGISTRY }}
+    #     MSAAS_REPO_CLONE_TOKEN: ${{ secrets.MSAAS_REPO_CLONE_TOKEN }}
+    #     MSAAS_REPO_URL: ${{ secrets.MSAAS_REPO_URL }}
+    #     MSAAS_REPO_FOLDER: /tmp/msaas
+    #   with:
+    #     limit-access-to-actor: true

.github/workflows/patch-build.yaml

@@ -2,7 +2,6 @@
 
 on:
   workflow_dispatch:
-    description: 'This workflow will build for patches for latest tag, and will Always use commit from main branch.'
     inputs:
       services:
         description: 'Comma separated names of services to build(in small letters).'
@@ -20,12 +19,20 @@ jobs:
       DEPOT_PROJECT_ID: ${{ secrets.DEPOT_PROJECT_ID }}
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
       with:
-        fetch-depth: 1
+        fetch-depth: 0
+        token: ${{ secrets.GITHUB_TOKEN }}
     - name: Rebase with main branch, to make sure the code has latest main changes
+      if: github.ref != 'refs/heads/main'
       run: |
-        git pull --rebase origin main
+        git remote -v
+        git config --global user.email "action@github.com"
+        git config --global user.name "GitHub Action"
+        git config --global rebase.autoStash true
+        git fetch origin main:main
+        git rebase main
+        git log -3
 
     - name: Downloading yq
       run: |
@@ -48,6 +55,8 @@ jobs:
         aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin ${{ secrets.RELEASE_OSS_REGISTRY }}
 
     - uses: depot/setup-action@v1
+      env:
+        DEPOT_TOKEN: ${{ secrets.DEPOT_TOKEN }}
     - name: Get HEAD Commit ID
       run: echo "HEAD_COMMIT_ID=$(git rev-parse HEAD)" >> $GITHUB_ENV
     - name: Define Branch Name
@@ -65,78 +74,168 @@ jobs:
         MSAAS_REPO_CLONE_TOKEN: ${{ secrets.MSAAS_REPO_CLONE_TOKEN }}
         MSAAS_REPO_URL: ${{ secrets.MSAAS_REPO_URL }}
         MSAAS_REPO_FOLDER: /tmp/msaas
+        SERVICES_INPUT: ${{ github.event.inputs.services }}
       run: |
-        set -exo pipefail
-        git config --local user.email "action@github.com"
-        git config --local user.name "GitHub Action"
-        git checkout -b $BRANCH_NAME
-        working_dir=$(pwd)
-        function image_version(){
-          local service=$1
-          chart_path="$working_dir/scripts/helmcharts/openreplay/charts/$service/Chart.yaml"
-          current_version=$(yq eval '.AppVersion' $chart_path)
-          new_version=$(echo $current_version | awk -F. '{$NF += 1 ; print $1"."$2"."$3}')
-          echo $new_version
-          # yq eval ".AppVersion = \"$new_version\"" -i $chart_path
+        #!/bin/bash
+        set -euo pipefail
+
+        # Configuration
+        readonly WORKING_DIR=$(pwd)
+        readonly BUILD_SCRIPT_NAME="build.sh"
+        readonly BACKEND_SERVICES_FILE="/tmp/backend.txt"
+
+        # Initialize git configuration
+        setup_git() {
+            git config --local user.email "action@github.com"
+            git config --local user.name "GitHub Action"
+            git checkout -b "$BRANCH_NAME"
         }
-        function clone_msaas() {
-          [ -d $MSAAS_REPO_FOLDER ] || {
-          git clone -b dev --recursive https://x-access-token:$MSAAS_REPO_CLONE_TOKEN@$MSAAS_REPO_URL $MSAAS_REPO_FOLDER
-          cd $MSAAS_REPO_FOLDER
-          cd openreplay && git fetch origin && git checkout main # This have to be changed to specific tag
-          git log -1
-          cd $MSAAS_REPO_FOLDER
-          bash git-init.sh
-          git checkout
-          }
+
+        # Get and increment image version
+        image_version() {
+            local service=$1
+            local chart_path="$WORKING_DIR/scripts/helmcharts/openreplay/charts/$service/Chart.yaml"
+            local current_version new_version
+
+            current_version=$(yq eval '.AppVersion' "$chart_path")
+            new_version=$(echo "$current_version" | awk -F. '{$NF += 1; print $1"."$2"."$3}')
+            echo "$new_version"
         }
-        function build_managed() {
-          local service=$1
-          local version=$2
-          echo building managed
-          clone_msaas
-          if [[ $service == 'chalice' ]]; then
-            cd $MSAAS_REPO_FOLDER/openreplay/api
-          else
-            cd $MSAAS_REPO_FOLDER/openreplay/$service
-          fi
-          IMAGE_TAG=$version DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=arm64 DOCKER_REPO=$DOCKER_REPO_ARM PUSH_IMAGE=0 bash build.sh >> /tmp/arm.txt
+
+        # Clone MSAAS repository if not exists
+        clone_msaas() {
+            if [[ ! -d "$MSAAS_REPO_FOLDER" ]]; then
+                git clone -b dev --recursive "https://x-access-token:${MSAAS_REPO_CLONE_TOKEN}@${MSAAS_REPO_URL}" "$MSAAS_REPO_FOLDER"
+                cd "$MSAAS_REPO_FOLDER"
+                cd openreplay && git fetch origin && git checkout main
+                git log -1
+                cd "$MSAAS_REPO_FOLDER"
+                bash git-init.sh
+                git checkout
+            fi
         }
-        # Checking for backend images
-        ls backend/cmd >> /tmp/backend.txt
-        echo Services: "${{ github.event.inputs.services }}"
-        IFS=',' read -ra SERVICES <<< "${{ github.event.inputs.services }}" 
-        BUILD_SCRIPT_NAME="build.sh"
-        # Build FOSS
-        for SERVICE in "${SERVICES[@]}"; do
-          # Check if service is backend
-          if grep -q $SERVICE /tmp/backend.txt; then 
-            cd backend 
-            foss_build_args="nil $SERVICE"
-            ee_build_args="ee $SERVICE"
-          else 
-            [[ $SERVICE == 'chalice' || $SERVICE == 'alerts' || $SERVICE == 'crons' ]] && cd $working_dir/api || cd $SERVICE
-            [[ $SERVICE == 'alerts' || $SERVICE == 'crons' ]] && BUILD_SCRIPT_NAME="build_${SERVICE}.sh"
-            ee_build_args="ee"
-          fi  
-          version=$(image_version $SERVICE)
-          echo IMAGE_TAG=$version DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=amd64 DOCKER_REPO=$DOCKER_REPO_OSS PUSH_IMAGE=0 bash ${BUILD_SCRIPT_NAME} $foss_build_args
-          IMAGE_TAG=$version DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=amd64 DOCKER_REPO=$DOCKER_REPO_OSS PUSH_IMAGE=0 bash ${BUILD_SCRIPT_NAME} $foss_build_args
-          echo IMAGE_TAG=$version-ee DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=amd64 DOCKER_REPO=$DOCKER_REPO_OSS PUSH_IMAGE=0 bash ${BUILD_SCRIPT_NAME} $ee_build_args
-          IMAGE_TAG=$version-ee DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=amd64 DOCKER_REPO=$DOCKER_REPO_OSS PUSH_IMAGE=0 bash ${BUILD_SCRIPT_NAME} $ee_build_args
-          if [[ "$SERVICE" != "chalice" && "$SERVICE" != "frontend" ]]; then
-            IMAGE_TAG=$version DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=arm64 DOCKER_REPO=$DOCKER_REPO_ARM PUSH_IMAGE=0 bash ${BUILD_SCRIPT_NAME} $foss_build_args
-            echo IMAGE_TAG=$version DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=arm64 DOCKER_REPO=$DOCKER_REPO_ARM PUSH_IMAGE=0 bash ${BUILD_SCRIPT_NAME} $foss_build_args
-          else
-            build_managed $SERVICE $version
-          fi
-          cd $working_dir
-          chart_path="$working_dir/scripts/helmcharts/openreplay/charts/$SERVICE/Chart.yaml"
-          yq eval ".AppVersion = \"$version\"" -i $chart_path
-          git add $chart_path
-          git commit -m "Increment $SERVICE chart version"
-          git push --set-upstream origin $BRANCH_NAME
-        done
+
+        # Build managed services
+        build_managed() {
+            local service=$1
+            local version=$2
+
+            echo "Building managed service: $service"
+            clone_msaas
+
+            if [[ $service == 'chalice' ]]; then
+                cd "$MSAAS_REPO_FOLDER/openreplay/api"
+            else
+                cd "$MSAAS_REPO_FOLDER/openreplay/$service"
+            fi
+
+            local build_cmd="IMAGE_TAG=$version DOCKER_RUNTIME=depot DOCKER_BUILD_ARGS=--push ARCH=arm64 DOCKER_REPO=$DOCKER_REPO_ARM PUSH_IMAGE=0 bash build.sh"
+
+            echo "Executing: $build_cmd"
+            if ! eval "$build_cmd" 2>&1; then
+                echo "Build failed for $service"
+                exit 1
+            fi
+        }
+
+        # Build service with given arguments
+        build_service() {
+            local service=$1
+            local version=$2
+            local build_args=$3
+            local build_script=${4:-$BUILD_SCRIPT_NAME}
+
+            local command="IMAGE_TAG=$version DOCKER_RUNTIME=depot DOCKER_BUILD_ARGS=--push ARCH=amd64 DOCKER_REPO=$DOCKER_REPO_OSS PUSH_IMAGE=0 bash $build_script $build_args"
+            echo "Executing: $command"
+            eval "$command"
+        }
+
+        # Update chart version and commit changes
+        update_chart_version() {
+            local service=$1
+            local version=$2
+            local chart_path="$WORKING_DIR/scripts/helmcharts/openreplay/charts/$service/Chart.yaml"
+
+            # Ensure we're in the original working directory/repository
+            cd "$WORKING_DIR"
+            yq eval ".AppVersion = \"$version\"" -i "$chart_path"
+            git add "$chart_path"
+            git commit -m "Increment $service chart version to $version"
+            git push --set-upstream origin "$BRANCH_NAME"
+            cd -
+        }
+
+        # Main execution
+        main() {
+            setup_git
+
+            # Get backend services list
+            ls backend/cmd >"$BACKEND_SERVICES_FILE"
+
+            # Parse services input (fix for GitHub Actions syntax)
+            echo "Services: ${SERVICES_INPUT:-$1}"
+            IFS=',' read -ra services <<<"${SERVICES_INPUT:-$1}"
+
+            # Process each service
+            for service in "${services[@]}"; do
+                echo "Processing service: $service"
+                cd "$WORKING_DIR"
+
+                local foss_build_args="" ee_build_args="" build_script="$BUILD_SCRIPT_NAME"
+
+                # Determine build configuration based on service type
+                if grep -q "$service" "$BACKEND_SERVICES_FILE"; then
+                    # Backend service
+                    cd backend
+                    foss_build_args="nil $service"
+                    ee_build_args="ee $service"
+                else
+                    # Non-backend service
+                    case "$service" in
+                    chalice | alerts | crons)
+                        cd "$WORKING_DIR/api"
+                        ;;
+                    *)
+                        cd "$service"
+                        ;;
+                    esac
+
+                    # Special build scripts for alerts/crons
+                    if [[ $service == 'alerts' || $service == 'crons' ]]; then
+                        build_script="build_${service}.sh"
+                    fi
+
+                    ee_build_args="ee"
+                fi
+
+                # Get version and build
+                local version
+                version=$(image_version "$service")
+
+                # Build FOSS and EE versions
+                build_service "$service" "$version" "$foss_build_args"
+                build_service "$service" "${version}-ee" "$ee_build_args"
+
+                # Build managed version for specific services
+                if [[ "$service" != "chalice" && "$service" != "frontend" ]]; then
+                    echo "Nothing to build in managed for service $service"
+                else
+                    build_managed "$service" "$version"
+                fi
+
+                # Update chart and commit
+                update_chart_version "$service" "$version"
+            done
+            cd "$WORKING_DIR"
+
+            # Cleanup
+            rm -f "$BACKEND_SERVICES_FILE"
+        }
+
+        echo "Working directory: $WORKING_DIR"
+        # Run main function with all arguments
+        main "$SERVICES_INPUT"
+        
 
     - name: Create Pull Request
       uses: repo-sync/pull-request@v2
@@ -147,8 +246,7 @@ jobs:
         pr_title: "Updated patch build from main ${{ env.HEAD_COMMIT_ID }}"
         pr_body: | 
           This PR updates the Helm chart version after building the patch from $HEAD_COMMIT_ID.
-          Once this PR is merged, To update the latest tag, run the following workflow.
-          https://github.com/openreplay/openreplay/actions/workflows/update-tag.yaml
+          Once this PR is merged, tag update job will run automatically.
 
     # - name: Debug Job
     #   if: ${{ failure() }}

.github/workflows/update-tag.yaml

@@ -1,35 +1,42 @@
 on:
-  workflow_dispatch:
-    description: "This workflow will build for patches for latest tag, and will Always use commit from main branch."
-    inputs:
-      services:
-        description: "This action will update the latest tag with current main branch HEAD. Should I proceed ? true/false"
-        required: true
-        default: "false"
-
-name: Force Push tag with main branch HEAD
+  pull_request:
+    types: [closed]
+    branches:
+      - main
+name: Release tag update --force
 
 jobs:
   deploy:
     name: Build Patch from main
     runs-on: ubuntu-latest
-    env:
-      DEPOT_TOKEN: ${{ secrets.DEPOT_TOKEN }}
-      DEPOT_PROJECT_ID: ${{ secrets.DEPOT_PROJECT_ID }}
+    if: ${{ (github.event_name == 'pull_request' && github.event.pull_request.merged == true) || github.event.inputs.services == 'true' }}
     steps:
       - name: Checkout
         uses: actions/checkout@v2
+
+      - name: Get latest release tag using GitHub API
+        id: get-latest-tag
+        run: |
+          LATEST_TAG=$(curl -s -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+            "https://api.github.com/repos/${{ github.repository }}/releases/latest" \
+            | jq -r .tag_name)
+          
+          # Fallback to git command if API doesn't return a tag
+          if [ "$LATEST_TAG" == "null" ] || [ -z "$LATEST_TAG" ]; then
+            echo "Not found latest tag"
+            exit 100
+          fi
+          
+          echo "LATEST_TAG=$LATEST_TAG" >> $GITHUB_ENV
+          echo "Latest tag: $LATEST_TAG"
+
       - name: Set Remote with GITHUB_TOKEN
         run: |
           git config --unset http.https://github.com/.extraheader
-          git remote set-url origin https://x-access-token:${{ secrets.ACTIONS_COMMMIT_TOKEN }}@github.com/${{ github.repository }}.git
+          git remote set-url origin https://x-access-token:${{ secrets.ACTIONS_COMMMIT_TOKEN }}@github.com/${{ github.repository }}
+
       - name: Push main branch to tag
         run: |
-          git fetch --tags
           git checkout main
-          git push origin HEAD:refs/tags/$(git tag --list 'v[0-9]*' --sort=-v:refname | head -n 1) --force
-    # - name: Debug Job
-    #   if: ${{ failure() }}
-    #   uses: mxschmitt/action-tmate@v3
-    #   with:
-    #     limit-access-to-actor: true
+          echo "Updating tag ${{ env.LATEST_TAG }} to point to latest commit on main"
+          git push origin HEAD:refs/tags/${{ env.LATEST_TAG }} --force

api/Pipfile

@@ -6,15 +6,16 @@ name = "pypi"
 [packages]
 urllib3 = "==2.3.0"
 requests = "==2.32.3"
-boto3 = "==1.37.16"
+boto3 = "==1.36.12"
 pyjwt = "==2.10.1"
 psycopg2-binary = "==2.9.10"
-psycopg = {extras = ["binary", "pool"], version = "==3.2.6"}
+psycopg = {extras = ["pool", "binary"], version = "==3.2.4"}
+clickhouse-driver = {extras = ["lz4"], version = "==0.2.9"}
 clickhouse-connect = "==0.8.15"
-elasticsearch = "==8.17.2"
+elasticsearch = "==8.17.1"
 jira = "==3.8.0"
-cachetools = "==5.5.2"
-fastapi = "==0.115.11"
+cachetools = "==5.5.1"
+fastapi = "==0.115.8"
 uvicorn = {extras = ["standard"], version = "==0.34.0"}
 python-decouple = "==3.8"
 pydantic = {extras = ["email"], version = "==2.10.6"}

api/app.py

@@ -16,7 +16,7 @@ from chalicelib.utils import helper
 from chalicelib.utils import pg_client, ch_client
 from crons import core_crons, core_dynamic_crons
 from routers import core, core_dynamic
-from routers.subs import insights, metrics, v1_api, health, usability_tests, spot, product_analytics
+from routers.subs import insights, metrics, v1_api, health, usability_tests, spot, product_anaytics
 
 loglevel = config("LOGLEVEL", default=logging.WARNING)
 print(f">Loglevel set to: {loglevel}")
@@ -129,6 +129,6 @@ app.include_router(spot.public_app)
 app.include_router(spot.app)
 app.include_router(spot.app_apikey)
 
-app.include_router(product_analytics.public_app, prefix="/pa")
-app.include_router(product_analytics.app, prefix="/pa")
-app.include_router(product_analytics.app_apikey, prefix="/pa")
+app.include_router(product_anaytics.public_app)
+app.include_router(product_anaytics.app)
+app.include_router(product_anaytics.app_apikey)

api/chalicelib/core/autocomplete/autocomplete.py

@@ -85,7 +85,8 @@ def __generic_query(typename, value_length=None):
                       ORDER BY value"""
 
     if value_length is None or value_length > 2:
-        return f"""(SELECT DISTINCT value, type
+        return f"""SELECT DISTINCT ON(value,type) value, type
+                   ((SELECT DISTINCT value, type
                     FROM {TABLE}
                     WHERE
                       project_id = %(project_id)s
@@ -101,7 +102,7 @@ def __generic_query(typename, value_length=None):
                       AND type='{typename.upper()}'
                       AND value ILIKE %(value)s
                       ORDER BY value
-                    LIMIT 5);"""
+                    LIMIT 5)) AS raw;"""
     return f"""SELECT DISTINCT value, type
                 FROM {TABLE}
                 WHERE
@@ -326,7 +327,7 @@ def __search_metadata(project_id, value, key=None, source=None):
                                 AND {colname} ILIKE %(svalue)s LIMIT 5)""")
     with pg_client.PostgresClient() as cur:
         cur.execute(cur.mogrify(f"""\
-                    SELECT key, value, 'METADATA' AS TYPE
+                    SELECT DISTINCT ON(key, value) key, value, 'METADATA' AS TYPE
                     FROM({" UNION ALL ".join(sub_from)}) AS all_metas
                     LIMIT 5;""", {"project_id": project_id, "value": helper.string_to_sql_like(value),
                                   "svalue": helper.string_to_sql_like("^" + value)}))

api/chalicelib/core/errors/errors_ch.py

@@ -338,14 +338,14 @@ def search(data: schemas.SearchErrorsSchema, project: schemas.ProjectContext, us
                 SELECT details.error_id as error_id,
                         name, message, users, total, 
                         sessions, last_occurrence, first_occurrence, chart
-                FROM (SELECT JSONExtractString(toString(`$properties`), 'error_id') AS error_id,
+                FROM (SELECT error_id,
                              JSONExtractString(toString(`$properties`), 'name') AS name,
                              JSONExtractString(toString(`$properties`), 'message') AS message,
                              COUNT(DISTINCT user_id)  AS users,
                              COUNT(DISTINCT events.session_id) AS sessions,
                              MAX(created_at)              AS max_datetime,
                              MIN(created_at)              AS min_datetime,
-                             COUNT(DISTINCT JSONExtractString(toString(`$properties`), 'error_id')) 
+                             COUNT(DISTINCT error_id) 
                                 OVER() AS total
                       FROM {MAIN_EVENTS_TABLE} AS events
                             INNER JOIN (SELECT session_id, coalesce(user_id,toString(user_uuid)) AS user_id 
@@ -357,7 +357,7 @@ def search(data: schemas.SearchErrorsSchema, project: schemas.ProjectContext, us
                       GROUP BY error_id, name, message
                       ORDER BY {sort} {order}
                       LIMIT %(errors_limit)s OFFSET %(errors_offset)s) AS details 
-                        INNER JOIN (SELECT JSONExtractString(toString(`$properties`), 'error_id') AS error_id, 
+                        INNER JOIN (SELECT error_id, 
                                             toUnixTimestamp(MAX(created_at))*1000 AS last_occurrence, 
                                             toUnixTimestamp(MIN(created_at))*1000 AS first_occurrence
                                      FROM {MAIN_EVENTS_TABLE}
@@ -366,7 +366,7 @@ def search(data: schemas.SearchErrorsSchema, project: schemas.ProjectContext, us
                                      GROUP BY error_id) AS time_details
                 ON details.error_id=time_details.error_id
                     INNER JOIN (SELECT error_id, groupArray([timestamp, count]) AS chart
-                    FROM (SELECT JSONExtractString(toString(`$properties`), 'error_id') AS error_id, 
+                    FROM (SELECT error_id, 
                                  gs.generate_series AS timestamp,
                                  COUNT(DISTINCT session_id) AS count
                             FROM generate_series(%(startDate)s, %(endDate)s, %(step_size)s) AS gs

api/chalicelib/core/issue_tracking/jira_cloud.py

@@ -50,8 +50,8 @@ class JIRAIntegration(base.BaseIntegration):
             cur.execute(
                 cur.mogrify(
                     """SELECT username, token, url
-                        FROM public.jira_cloud 
-                        WHERE user_id=%(user_id)s;""",
+                       FROM public.jira_cloud
+                       WHERE user_id = %(user_id)s;""",
                     {"user_id": self._user_id})
             )
             data = helper.dict_to_camel_case(cur.fetchone())
@@ -95,10 +95,9 @@ class JIRAIntegration(base.BaseIntegration):
     def add(self, username, token, url, obfuscate=False):
         with pg_client.PostgresClient() as cur:
             cur.execute(
-                cur.mogrify("""\
-                        INSERT INTO public.jira_cloud(username, token, user_id,url)
-                        VALUES (%(username)s, %(token)s, %(user_id)s,%(url)s)
-                        RETURNING  username, token, url;""",
+                cur.mogrify(""" \
+                            INSERT INTO public.jira_cloud(username, token, user_id, url)
+                            VALUES (%(username)s, %(token)s, %(user_id)s, %(url)s) RETURNING  username, token, url;""",
                             {"user_id": self._user_id, "username": username,
                              "token": token, "url": url})
             )
@@ -112,9 +111,10 @@ class JIRAIntegration(base.BaseIntegration):
     def delete(self):
         with pg_client.PostgresClient() as cur:
             cur.execute(
-                cur.mogrify("""\
-                        DELETE FROM public.jira_cloud
-                        WHERE user_id=%(user_id)s;""",
+                cur.mogrify(""" \
+                            DELETE
+                            FROM public.jira_cloud
+                            WHERE user_id = %(user_id)s;""",
                             {"user_id": self._user_id})
             )
             return {"state": "success"}
@@ -125,7 +125,7 @@ class JIRAIntegration(base.BaseIntegration):
                 changes={
                     "username": data.username,
                     "token": data.token if len(data.token) > 0 and data.token.find("***") == -1 \
-                        else self.integration.token,
+                        else self.integration["token"],
                     "url": str(data.url)
                 },
                 obfuscate=True

api/chalicelib/core/metrics/product_analytics/product_analytics_ch.py

@@ -85,6 +85,9 @@ def __complete_missing_steps(start_time, end_time, density, neutral, rows, time_
 # compute avg_time_from_previous at the same level as sessions_count (this was removed in v1.22)
 # if start-point is selected, the selected event is ranked n°1
 def path_analysis(project_id: int, data: schemas.CardPathAnalysis):
+    if not data.hide_excess:
+        data.hide_excess = True
+        data.rows = 50
     sub_events = []
     start_points_conditions = []
     step_0_conditions = []

api/chalicelib/core/metrics/product_anaytics2.py

@@ -0,0 +1,14 @@
+from chalicelib.utils.ch_client import ClickHouseClient
+
+
+def search_events(project_id: int, data: dict):
+    with ClickHouseClient() as ch_client:
+        r = ch_client.format(
+            """SELECT * 
+                      FROM taha.events 
+                      WHERE project_id=%(project_id)s
+                      ORDER BY created_at;""",
+            params={"project_id": project_id})
+        x = ch_client.execute(r)
+
+        return x

api/chalicelib/core/product_analytics/events.py

@@ -1,108 +0,0 @@
-import logging
-
-import schemas
-from chalicelib.utils import helper
-from chalicelib.utils import sql_helper as sh
-from chalicelib.utils.ch_client import ClickHouseClient
-
-logger = logging.getLogger(__name__)
-
-
-def get_events(project_id: int):
-    with ClickHouseClient() as ch_client:
-        r = ch_client.format(
-            """SELECT event_name, display_name
-                      FROM product_analytics.all_events 
-                      WHERE project_id=%(project_id)s
-                      ORDER BY display_name;""",
-            parameters={"project_id": project_id})
-        x = ch_client.execute(r)
-
-        return helper.list_to_camel_case(x)
-
-
-def search_events(project_id: int, data: schemas.EventsSearchPayloadSchema):
-    with ClickHouseClient() as ch_client:
-        full_args = {"project_id": project_id, "startDate": data.startTimestamp, "endDate": data.endTimestamp,
-                     "projectId": project_id, "limit": data.limit, "offset": (data.page - 1) * data.limit}
-
-        constraints = ["project_id = %(projectId)s",
-                       "created_at >= toDateTime(%(startDate)s/1000)",
-                       "created_at <= toDateTime(%(endDate)s/1000)"]
-        for i, f in enumerate(data.filters):
-            f.value = helper.values_for_operator(value=f.value, op=f.operator)
-            f_k = f"f_value{i}"
-            full_args = {**full_args, f_k: sh.single_value(f.value), **sh.multi_values(f.value, value_key=f_k)}
-            op = sh.get_sql_operator(f.operator)
-            is_any = sh.isAny_opreator(f.operator)
-            is_undefined = sh.isUndefined_operator(f.operator)
-            full_args = {**full_args, f_k: sh.single_value(f.value), **sh.multi_values(f.value, value_key=f_k)}
-            if f.is_predefined:
-                column = f.name
-            else:
-                column = f"properties.{f.name}"
-
-            if is_any:
-                condition = f"isNotNull({column})"
-            elif is_undefined:
-                condition = f"isNull({column})"
-            else:
-                condition = sh.multi_conditions(f"{column} {op} %({f_k})s", f.value, value_key=f_k)
-            constraints.append(condition)
-
-        ev_constraints = []
-        for i, e in enumerate(data.events):
-            e_k = f"e_value{i}"
-            full_args = {**full_args, e_k: e.event_name}
-            condition = f"`$event_name` = %({e_k})s"
-            sub_conditions = []
-            if len(e.properties.filters) > 0:
-                for j, f in enumerate(e.properties.filters):
-                    p_k = f"e_{i}_p_{j}"
-                    full_args = {**full_args, **sh.multi_values(f.value, value_key=p_k)}
-                    if f.is_predefined:
-                        sub_condition = f"{f.name} {op} %({p_k})s"
-                    else:
-                        sub_condition = f"properties.{f.name} {op} %({p_k})s"
-                    sub_conditions.append(sh.multi_conditions(sub_condition, f.value, value_key=p_k))
-                if len(sub_conditions) > 0:
-                    condition += " AND ("
-                    for j, c in enumerate(sub_conditions):
-                        if j > 0:
-                            condition += " " + e.properties.operators[j - 1] + " " + c
-                        else:
-                            condition += c
-                    condition += ")"
-
-            ev_constraints.append(condition)
-
-        constraints.append("(" + " OR ".join(ev_constraints) + ")")
-        query = ch_client.format(
-            f"""SELECT COUNT(1) OVER () AS total, 
-                            event_id,
-                           `$event_name`,
-                           created_at,
-                           `distinct_id`,
-                           `$browser`,
-                           `$import`,
-                           `$os`,
-                           `$country`,
-                           `$state`,
-                           `$city`,
-                           `$screen_height`,
-                           `$screen_width`,
-                           `$source`,
-                           `$user_id`,
-                           `$device` 
-                      FROM product_analytics.events 
-                      WHERE {" AND ".join(constraints)} 
-                      ORDER BY created_at
-                      LIMIT %(limit)s OFFSET %(offset)s;""",
-            parameters=full_args)
-        rows = ch_client.execute(query)
-        if len(rows) == 0:
-            return {"total": 0, "rows": [], "src": 2}
-        total = rows[0]["total"]
-        for r in rows:
-            r.pop("total")
-        return {"total": total, "rows": rows, "src": 2}

api/chalicelib/core/product_analytics/properties.py

@@ -1,19 +0,0 @@
-from chalicelib.utils import helper
-from chalicelib.utils.ch_client import ClickHouseClient
-
-
-def get_properties(project_id: int, event_name):
-    with ClickHouseClient() as ch_client:
-        r = ch_client.format(
-            """SELECT all_properties.property_name,
-                            all_properties.display_name
-                      FROM product_analytics.event_properties 
-                        INNER JOIN product_analytics.all_properties USING (property_name) 
-                      WHERE event_properties.project_id=%(project_id)s
-                        AND all_properties.project_id=%(project_id)s
-                        AND event_properties.event_name=%(event_name)s
-                      ORDER BY created_at;""",
-            parameters={"project_id": project_id,"event_name": event_name})
-        properties = ch_client.execute(r)
-
-        return helper.list_to_camel_case(properties)

api/chalicelib/core/sessions/__init__.py

@@ -6,18 +6,8 @@ logger = logging.getLogger(__name__)
 from . import sessions_pg
 from . import sessions_pg as sessions_legacy
 from . import sessions_ch
-from . import sessions_search_pg
-from . import sessions_search_pg as sessions_search_legacy
 
-if config("EXP_SESSIONS_SEARCH", cast=bool, default=False):
-    logger.info(">>> Using experimental sessions search")
+if config("EXP_METRICS", cast=bool, default=False):
     from . import sessions_ch as sessions
-    from . import sessions_search_ch as sessions_search
 else:
     from . import sessions_pg as sessions
-    from . import sessions_search_pg as sessions_search
-
-# if config("EXP_METRICS", cast=bool, default=False):
-#     from . import sessions_ch as sessions
-# else:
-#     from . import sessions_pg as sessions

api/chalicelib/core/sessions/sessions_ch.py

@@ -153,7 +153,7 @@ def search2_table(data: schemas.SessionsSearchPayloadSchema, project_id: int, de
                         "isEvent": True,
                         "value": [],
                         "operator": e.operator,
-                        "filters": []
+                        "filters": e.filters
                     })
                 for v in e.value:
                     if v not in extra_conditions[e.operator].value:
@@ -178,7 +178,7 @@ def search2_table(data: schemas.SessionsSearchPayloadSchema, project_id: int, de
                         "isEvent": True,
                         "value": [],
                         "operator": e.operator,
-                        "filters": []
+                        "filters": e.filters
                     })
                 for v in e.value:
                     if v not in extra_conditions[e.operator].value:
@@ -671,36 +671,24 @@ def search_query_parts_ch(data: schemas.SessionsSearchPayloadSchema, error_statu
                     events_conditions.append({"type": event_where[-1]})
                     if not is_any:
                         if schemas.ClickEventExtraOperator.has_value(event.operator):
-                            # event_where.append(json_condition(
-                            #     "main",
-                            #     "$properties",
-                            #     "selector", op, event.value, e_k)
-                            # )
-                            event_where.append(
-                                sh.multi_conditions(f"main.`$properties`.selector {op} %({e_k})s",
-                                                    event.value, value_key=e_k)
+                            event_where.append(json_condition(
+                                "main",
+                                "$properties",
+                                "selector", op, event.value, e_k)
                             )
                             events_conditions[-1]["condition"] = event_where[-1]
                         else:
                             if is_not:
-                                # event_where.append(json_condition(
-                                #     "sub", "$properties", _column, op, event.value, e_k
-                                # ))
-                                event_where.append(
-                                    sh.multi_conditions(f"sub.`$properties`.{_column} {op} %({e_k})s",
-                                                        event.value, value_key=e_k)
-                                )
+                                event_where.append(json_condition(
+                                    "sub", "$properties", _column, op, event.value, e_k
+                                ))
                                 events_conditions_not.append(
                                     {
                                         "type": f"sub.`$event_name`='{exp_ch_helper.get_event_type(event_type, platform=platform)}'"})
                                 events_conditions_not[-1]["condition"] = event_where[-1]
                             else:
-                                # event_where.append(
-                                #     json_condition("main", "$properties", _column, op, event.value, e_k)
-                                # )
                                 event_where.append(
-                                    sh.multi_conditions(f"main.`$properties`.{_column} {op} %({e_k})s",
-                                                        event.value, value_key=e_k)
+                                    json_condition("main", "$properties", _column, op, event.value, e_k)
                                 )
                                 events_conditions[-1]["condition"] = event_where[-1]
                 else:
@@ -882,15 +870,12 @@ def search_query_parts_ch(data: schemas.SessionsSearchPayloadSchema, error_statu
                 events_conditions[-1]["condition"] = []
                 if not is_any and event.value not in [None, "*", ""]:
                     event_where.append(
-                        sh.multi_conditions(
-                            f"(toString(main1.`$properties`.message) {op} %({e_k})s OR toString(main1.`$properties`.name) {op} %({e_k})s)",
-                            event.value, value_key=e_k))
+                        sh.multi_conditions(f"(toString(main1.`$properties`.message) {op} %({e_k})s OR toString(main1.`$properties`.name) {op} %({e_k})s)",
+                                            event.value, value_key=e_k))
                     events_conditions[-1]["condition"].append(event_where[-1])
                     events_extra_join += f" AND {event_where[-1]}"
                 if len(event.source) > 0 and event.source[0] not in [None, "*", ""]:
-                    event_where.append(
-                        sh.multi_conditions(f"toString(main1.`$properties`.source) = %({s_k})s", event.source,
-                                            value_key=s_k))
+                    event_where.append(sh.multi_conditions(f"toString(main1.`$properties`.source) = %({s_k})s", event.source, value_key=s_k))
                     events_conditions[-1]["condition"].append(event_where[-1])
                     events_extra_join += f" AND {event_where[-1]}"
 
@@ -1123,8 +1108,12 @@ def search_query_parts_ch(data: schemas.SessionsSearchPayloadSchema, error_statu
                     is_any = sh.isAny_opreator(f.operator)
                     if is_any or len(f.value) == 0:
                         continue
+                    is_negative_operator = sh.is_negation_operator(f.operator)
                     f.value = helper.values_for_operator(value=f.value, op=f.operator)
                     op = sh.get_sql_operator(f.operator)
+                    r_op = ""
+                    if is_negative_operator:
+                        r_op = sh.reverse_sql_operator(op)
                     e_k_f = e_k + f"_fetch{j}"
                     full_args = {**full_args, **sh.multi_values(f.value, value_key=e_k_f)}
                     if f.type == schemas.FetchFilterType.FETCH_URL:
@@ -1133,6 +1122,12 @@ def search_query_parts_ch(data: schemas.SessionsSearchPayloadSchema, error_statu
                         ))
                         events_conditions[-1]["condition"].append(event_where[-1])
                         apply = True
+                        if is_negative_operator:
+                            events_conditions_not.append(
+                                {
+                                    "type": f"sub.`$event_name`='{exp_ch_helper.get_event_type(event_type, platform=platform)}'"})
+                            events_conditions_not[-1]["condition"] = sh.multi_conditions(
+                                f"sub.`$properties`.url_path {r_op} %({e_k_f})s", f.value, value_key=e_k_f)
                     elif f.type == schemas.FetchFilterType.FETCH_STATUS_CODE:
                         event_where.append(json_condition(
                             "main", "$properties", 'status', op, f.value, e_k_f, True, True
@@ -1145,6 +1140,13 @@ def search_query_parts_ch(data: schemas.SessionsSearchPayloadSchema, error_statu
                         ))
                         events_conditions[-1]["condition"].append(event_where[-1])
                         apply = True
+                        if is_negative_operator:
+                            events_conditions_not.append(
+                                {
+                                    "type": f"sub.`$event_name`='{exp_ch_helper.get_event_type(event_type, platform=platform)}'"})
+                            events_conditions_not[-1]["condition"] = sh.multi_conditions(
+                                f"sub.`$properties`.method {r_op} %({e_k_f})s", f.value,
+                                value_key=e_k_f)
                     elif f.type == schemas.FetchFilterType.FETCH_DURATION:
                         event_where.append(
                             sh.multi_conditions(f"main.`$duration_s` {f.operator} %({e_k_f})s/1000", f.value,
@@ -1157,12 +1159,26 @@ def search_query_parts_ch(data: schemas.SessionsSearchPayloadSchema, error_statu
                         ))
                         events_conditions[-1]["condition"].append(event_where[-1])
                         apply = True
+                        if is_negative_operator:
+                            events_conditions_not.append(
+                                {
+                                    "type": f"sub.`$event_name`='{exp_ch_helper.get_event_type(event_type, platform=platform)}'"})
+                            events_conditions_not[-1]["condition"] = sh.multi_conditions(
+                                f"sub.`$properties`.request_body {r_op} %({e_k_f})s", f.value,
+                                value_key=e_k_f)
                     elif f.type == schemas.FetchFilterType.FETCH_RESPONSE_BODY:
                         event_where.append(json_condition(
                             "main", "$properties", 'response_body', op, f.value, e_k_f
                         ))
                         events_conditions[-1]["condition"].append(event_where[-1])
                         apply = True
+                        if is_negative_operator:
+                            events_conditions_not.append(
+                                {
+                                    "type": f"sub.`$event_name`='{exp_ch_helper.get_event_type(event_type, platform=platform)}'"})
+                            events_conditions_not[-1]["condition"] = sh.multi_conditions(
+                                f"sub.`$properties`.response_body {r_op} %({e_k_f})s", f.value,
+                                value_key=e_k_f)
                     else:
                         logging.warning(f"undefined FETCH filter: {f.type}")
                 if not apply:
@@ -1208,28 +1224,6 @@ def search_query_parts_ch(data: schemas.SessionsSearchPayloadSchema, error_statu
                 events_conditions[-1]["condition"] = " AND ".join(events_conditions[-1]["condition"])
             else:
                 continue
-            if event.properties is not None and len(event.properties.filters) > 0:
-                event_fiters = []
-                for l, property in enumerate(event.properties.filters):
-                    a_k = f"{e_k}_att_{l}"
-                    full_args = {**full_args,
-                                 **sh.multi_values(property.value, value_key=a_k)}
-                    op = sh.get_sql_operator(property.operator)
-                    condition = f"main.properties.{property.name} {op} %({a_k})s"
-                    if property.is_predefined:
-                        condition = f"main.{property.name} {op} %({a_k})s"
-                    event_where.append(
-                        sh.multi_conditions(condition, property.value, value_key=a_k)
-                    )
-                    event_fiters.append(event_where[-1])
-                if len(event_fiters) > 0:
-                    events_conditions[-1]["condition"] += " AND ("
-                    for l, e_f in enumerate(event_fiters):
-                        if l > 0:
-                            events_conditions[-1]["condition"] += event.properties.operators[l - 1] + e_f
-                        else:
-                            events_conditions[-1]["condition"] += e_f
-                    events_conditions[-1]["condition"] += ")"
             if event_index == 0 or or_events:
                 event_where += ss_constraints
             if is_not:
@@ -1432,17 +1426,30 @@ def search_query_parts_ch(data: schemas.SessionsSearchPayloadSchema, error_statu
         if extra_conditions and len(extra_conditions) > 0:
             _extra_or_condition = []
             for i, c in enumerate(extra_conditions):
-                if sh.isAny_opreator(c.operator):
+                if sh.isAny_opreator(c.operator) and c.type != schemas.EventType.REQUEST_DETAILS.value:
                     continue
                 e_k = f"ec_value{i}"
                 op = sh.get_sql_operator(c.operator)
                 c.value = helper.values_for_operator(value=c.value, op=c.operator)
                 full_args = {**full_args,
                              **sh.multi_values(c.value, value_key=e_k)}
-                if c.type == events.EventType.LOCATION.ui_type:
+                if c.type in (schemas.EventType.LOCATION.value, schemas.EventType.REQUEST.value):
                     _extra_or_condition.append(
                         sh.multi_conditions(f"extra_event.url_path {op} %({e_k})s",
                                             c.value, value_key=e_k))
+                elif c.type == schemas.EventType.REQUEST_DETAILS.value:
+                    for j, c_f in enumerate(c.filters):
+                        if sh.isAny_opreator(c_f.operator) or len(c_f.value) == 0:
+                            continue
+                        e_k += f"_{j}"
+                        op = sh.get_sql_operator(c_f.operator)
+                        c_f.value = helper.values_for_operator(value=c_f.value, op=c_f.operator)
+                        full_args = {**full_args,
+                                     **sh.multi_values(c_f.value, value_key=e_k)}
+                        if c_f.type == schemas.FetchFilterType.FETCH_URL.value:
+                            _extra_or_condition.append(
+                                sh.multi_conditions(f"extra_event.url_path {op} %({e_k})s",
+                                                     c_f.value, value_key=e_k))
                 else:
                     logging.warning(f"unsupported extra_event type:${c.type}")
             if len(_extra_or_condition) > 0:

api/chalicelib/core/sessions/sessions_pg.py

@@ -148,7 +148,7 @@ def search2_table(data: schemas.SessionsSearchPayloadSchema, project_id: int, de
                         "isEvent": True,
                         "value": [],
                         "operator": e.operator,
-                        "filters": []
+                        "filters": e.filters
                     })
                 for v in e.value:
                     if v not in extra_conditions[e.operator].value:
@@ -165,7 +165,7 @@ def search2_table(data: schemas.SessionsSearchPayloadSchema, project_id: int, de
                         "isEvent": True,
                         "value": [],
                         "operator": e.operator,
-                        "filters": []
+                        "filters": e.filters
                     })
                 for v in e.value:
                     if v not in extra_conditions[e.operator].value:
@@ -989,7 +989,7 @@ def search_query_parts(data: schemas.SessionsSearchPayloadSchema, error_status,
                         sh.multi_conditions(f"ev.{events.EventType.LOCATION.column} {op} %({e_k})s",
                                             c.value, value_key=e_k))
                 else:
-                    logger.warning(f"unsupported extra_event type:${c.type}")
+                    logger.warning(f"unsupported extra_event type: {c.type}")
             if len(_extra_or_condition) > 0:
                 extra_constraints.append("(" + " OR ".join(_extra_or_condition) + ")")
     query_part = f"""\

api/chalicelib/utils/__init__.py

@@ -11,3 +11,9 @@ if smtp.has_smtp():
     logger.info("valid SMTP configuration found")
 else:
     logger.info("no SMTP configuration found or SMTP validation failed")
+
+if config("EXP_CH_DRIVER", cast=bool, default=True):
+    logging.info(">>> Using new CH driver")
+    from . import ch_client_exp as ch_client
+else:
+    from . import ch_client

api/chalicelib/utils/ch_client.py

@@ -1,185 +1,73 @@
 import logging
-import threading
-import time
-from functools import wraps
-from queue import Queue, Empty
 
-import clickhouse_connect
-from clickhouse_connect.driver.query import QueryContext
+import clickhouse_driver
 from decouple import config
 
 logger = logging.getLogger(__name__)
 
-_CH_CONFIG = {"host": config("ch_host"),
-              "user": config("ch_user", default="default"),
-              "password": config("ch_password", default=""),
-              "port": config("ch_port_http", cast=int),
-              "client_name": config("APP_NAME", default="PY")}
-CH_CONFIG = dict(_CH_CONFIG)
-
 settings = {}
 if config('ch_timeout', cast=int, default=-1) > 0:
-    logging.info(f"CH-max_execution_time set to {config('ch_timeout')}s")
+    logger.info(f"CH-max_execution_time set to {config('ch_timeout')}s")
     settings = {**settings, "max_execution_time": config('ch_timeout', cast=int)}
 
 if config('ch_receive_timeout', cast=int, default=-1) > 0:
-    logging.info(f"CH-receive_timeout set to {config('ch_receive_timeout')}s")
+    logger.info(f"CH-receive_timeout set to {config('ch_receive_timeout')}s")
     settings = {**settings, "receive_timeout": config('ch_receive_timeout', cast=int)}
 
-extra_args = {}
-if config("CH_COMPRESSION", cast=bool, default=True):
-    extra_args["compression"] = "lz4"
-
-
-def transform_result(self, original_function):
-    @wraps(original_function)
-    def wrapper(*args, **kwargs):
-        if kwargs.get("parameters"):
-            if config("LOCAL_DEV", cast=bool, default=False):
-                logger.debug(self.format(query=kwargs.get("query", ""), parameters=kwargs.get("parameters")))
-            else:
-                logger.debug(
-                    str.encode(self.format(query=kwargs.get("query", ""), parameters=kwargs.get("parameters"))))
-        elif len(args) > 0:
-            if config("LOCAL_DEV", cast=bool, default=False):
-                logger.debug(args[0])
-            else:
-                logger.debug(str.encode(args[0]))
-        result = original_function(*args, **kwargs)
-        if isinstance(result, clickhouse_connect.driver.query.QueryResult):
-            column_names = result.column_names
-            result = result.result_rows
-            result = [dict(zip(column_names, row)) for row in result]
-
-        return result
-
-    return wrapper
-
-
-class ClickHouseConnectionPool:
-    def __init__(self, min_size, max_size):
-        self.min_size = min_size
-        self.max_size = max_size
-        self.pool = Queue()
-        self.lock = threading.Lock()
-        self.total_connections = 0
-
-        # Initialize the pool with min_size connections
-        for _ in range(self.min_size):
-            client = clickhouse_connect.get_client(**CH_CONFIG,
-                                                   database=config("ch_database", default="default"),
-                                                   settings=settings,
-                                                   **extra_args)
-            self.pool.put(client)
-            self.total_connections += 1
-
-    def get_connection(self):
-        try:
-            # Try to get a connection without blocking
-            client = self.pool.get_nowait()
-            return client
-        except Empty:
-            with self.lock:
-                if self.total_connections < self.max_size:
-                    client = clickhouse_connect.get_client(**CH_CONFIG,
-                                                           database=config("ch_database", default="default"),
-                                                           settings=settings,
-                                                           **extra_args)
-                    self.total_connections += 1
-                    return client
-        # If max_size reached, wait until a connection is available
-        client = self.pool.get()
-        return client
-
-    def release_connection(self, client):
-        self.pool.put(client)
-
-    def close_all(self):
-        with self.lock:
-            while not self.pool.empty():
-                client = self.pool.get()
-                client.close()
-            self.total_connections = 0
-
-
-CH_pool: ClickHouseConnectionPool = None
-
-RETRY_MAX = config("CH_RETRY_MAX", cast=int, default=50)
-RETRY_INTERVAL = config("CH_RETRY_INTERVAL", cast=int, default=2)
-RETRY = 0
-
-
-def make_pool():
-    if not config('CH_POOL', cast=bool, default=True):
-        return
-    global CH_pool
-    global RETRY
-    if CH_pool is not None:
-        try:
-            CH_pool.close_all()
-        except Exception as error:
-            logger.error("Error while closing all connexions to CH", exc_info=error)
-    try:
-        CH_pool = ClickHouseConnectionPool(min_size=config("CH_MINCONN", cast=int, default=4),
-                                           max_size=config("CH_MAXCONN", cast=int, default=8))
-        if CH_pool is not None:
-            logger.info("Connection pool created successfully for CH")
-    except ConnectionError as error:
-        logger.error("Error while connecting to CH", exc_info=error)
-        if RETRY < RETRY_MAX:
-            RETRY += 1
-            logger.info(f"waiting for {RETRY_INTERVAL}s before retry n°{RETRY}")
-            time.sleep(RETRY_INTERVAL)
-            make_pool()
-        else:
-            raise error
-
 
 class ClickHouseClient:
     __client = None
 
     def __init__(self, database=None):
-        if self.__client is None:
-            if database is not None or not config('CH_POOL', cast=bool, default=True):
-                self.__client = clickhouse_connect.get_client(**CH_CONFIG,
-                                                              database=database if database else config("ch_database",
-                                                                                                        default="default"),
-                                                              settings=settings,
-                                                              **extra_args)
-
-            else:
-                self.__client = CH_pool.get_connection()
-
-            self.__client.execute = transform_result(self, self.__client.query)
-            self.__client.format = self.format
+        extra_args = {}
+        if config("CH_COMPRESSION", cast=bool, default=True):
+            extra_args["compression"] = "lz4"
+        self.__client = clickhouse_driver.Client(host=config("ch_host"),
+                                                 database=database if database else config("ch_database",
+                                                                                           default="default"),
+                                                 user=config("ch_user", default="default"),
+                                                 password=config("ch_password", default=""),
+                                                 port=config("ch_port", cast=int),
+                                                 settings=settings,
+                                                 **extra_args) \
+            if self.__client is None else self.__client
 
     def __enter__(self):
+        return self
+
+    def execute(self, query, parameters=None, **args):
+        try:
+            results = self.__client.execute(query=query, params=parameters, with_column_types=True, **args)
+            keys = tuple(x for x, y in results[1])
+            return [dict(zip(keys, i)) for i in results[0]]
+        except Exception as err:
+            logger.error("--------- CH EXCEPTION -----------", exc_info=err)
+            logger.error("--------- CH QUERY EXCEPTION -----------")
+            logger.error(self.format(query=query, parameters=parameters)
+                         .replace('\n', '\\n')
+                         .replace('    ', ' ')
+                         .replace('        ', ' '))
+            logger.error("--------------------")
+            raise err
+
+    def insert(self, query, params=None, **args):
+        return self.__client.execute(query=query, params=params, **args)
+
+    def client(self):
         return self.__client
 
-    def format(self, query, parameters=None):
-        if parameters:
-            ctx = QueryContext(query=query, parameters=parameters)
-            return ctx.final_query
-        return query
+    def format(self, query, parameters):
+        if parameters is None:
+            return query
+        return self.__client.substitute_params(query, parameters, self.__client.connection.context)
 
     def __exit__(self, *args):
-        if config('CH_POOL', cast=bool, default=True):
-            CH_pool.release_connection(self.__client)
-        else:
-            self.__client.close()
+        pass
 
 
 async def init():
-    logger.info(f">use CH_POOL:{config('CH_POOL', default=True)}")
-    if config('CH_POOL', cast=bool, default=True):
-        make_pool()
+    logger.info(f">CH_POOL:not defined")
 
 
 async def terminate():
-    global CH_pool
-    if CH_pool is not None:
-        try:
-            CH_pool.close_all()
-            logger.info("Closed all connexions to CH")
-        except Exception as error:
-            logger.error("Error while closing all connexions to CH", exc_info=error)
+    pass

api/chalicelib/utils/ch_client_exp.py

@@ -0,0 +1,178 @@
+import logging
+import threading
+import time
+from functools import wraps
+from queue import Queue, Empty
+
+import clickhouse_connect
+from clickhouse_connect.driver.query import QueryContext
+from decouple import config
+
+logger = logging.getLogger(__name__)
+
+_CH_CONFIG = {"host": config("ch_host"),
+              "user": config("ch_user", default="default"),
+              "password": config("ch_password", default=""),
+              "port": config("ch_port_http", cast=int),
+              "client_name": config("APP_NAME", default="PY")}
+CH_CONFIG = dict(_CH_CONFIG)
+
+settings = {}
+if config('ch_timeout', cast=int, default=-1) > 0:
+    logging.info(f"CH-max_execution_time set to {config('ch_timeout')}s")
+    settings = {**settings, "max_execution_time": config('ch_timeout', cast=int)}
+
+if config('ch_receive_timeout', cast=int, default=-1) > 0:
+    logging.info(f"CH-receive_timeout set to {config('ch_receive_timeout')}s")
+    settings = {**settings, "receive_timeout": config('ch_receive_timeout', cast=int)}
+
+extra_args = {}
+if config("CH_COMPRESSION", cast=bool, default=True):
+    extra_args["compression"] = "lz4"
+
+
+def transform_result(self, original_function):
+    @wraps(original_function)
+    def wrapper(*args, **kwargs):
+        if kwargs.get("parameters"):
+            logger.debug(str.encode(self.format(query=kwargs.get("query", ""), parameters=kwargs.get("parameters"))))
+        elif len(args) > 0:
+            logger.debug(str.encode(args[0]))
+        result = original_function(*args, **kwargs)
+        if isinstance(result, clickhouse_connect.driver.query.QueryResult):
+            column_names = result.column_names
+            result = result.result_rows
+            result = [dict(zip(column_names, row)) for row in result]
+
+        return result
+
+    return wrapper
+
+
+class ClickHouseConnectionPool:
+    def __init__(self, min_size, max_size):
+        self.min_size = min_size
+        self.max_size = max_size
+        self.pool = Queue()
+        self.lock = threading.Lock()
+        self.total_connections = 0
+
+        # Initialize the pool with min_size connections
+        for _ in range(self.min_size):
+            client = clickhouse_connect.get_client(**CH_CONFIG,
+                                                   database=config("ch_database", default="default"),
+                                                   settings=settings,
+                                                   **extra_args)
+            self.pool.put(client)
+            self.total_connections += 1
+
+    def get_connection(self):
+        try:
+            # Try to get a connection without blocking
+            client = self.pool.get_nowait()
+            return client
+        except Empty:
+            with self.lock:
+                if self.total_connections < self.max_size:
+                    client = clickhouse_connect.get_client(**CH_CONFIG,
+                                                           database=config("ch_database", default="default"),
+                                                           settings=settings,
+                                                           **extra_args)
+                    self.total_connections += 1
+                    return client
+        # If max_size reached, wait until a connection is available
+        client = self.pool.get()
+        return client
+
+    def release_connection(self, client):
+        self.pool.put(client)
+
+    def close_all(self):
+        with self.lock:
+            while not self.pool.empty():
+                client = self.pool.get()
+                client.close()
+            self.total_connections = 0
+
+
+CH_pool: ClickHouseConnectionPool = None
+
+RETRY_MAX = config("CH_RETRY_MAX", cast=int, default=50)
+RETRY_INTERVAL = config("CH_RETRY_INTERVAL", cast=int, default=2)
+RETRY = 0
+
+
+def make_pool():
+    if not config('CH_POOL', cast=bool, default=True):
+        return
+    global CH_pool
+    global RETRY
+    if CH_pool is not None:
+        try:
+            CH_pool.close_all()
+        except Exception as error:
+            logger.error("Error while closing all connexions to CH", exc_info=error)
+    try:
+        CH_pool = ClickHouseConnectionPool(min_size=config("CH_MINCONN", cast=int, default=4),
+                                           max_size=config("CH_MAXCONN", cast=int, default=8))
+        if CH_pool is not None:
+            logger.info("Connection pool created successfully for CH")
+    except ConnectionError as error:
+        logger.error("Error while connecting to CH", exc_info=error)
+        if RETRY < RETRY_MAX:
+            RETRY += 1
+            logger.info(f"waiting for {RETRY_INTERVAL}s before retry n°{RETRY}")
+            time.sleep(RETRY_INTERVAL)
+            make_pool()
+        else:
+            raise error
+
+
+class ClickHouseClient:
+    __client = None
+
+    def __init__(self, database=None):
+        if self.__client is None:
+            if database is not None or not config('CH_POOL', cast=bool, default=True):
+                self.__client = clickhouse_connect.get_client(**CH_CONFIG,
+                                                              database=database if database else config("ch_database",
+                                                                                                        default="default"),
+                                                              settings=settings,
+                                                              **extra_args)
+
+            else:
+                self.__client = CH_pool.get_connection()
+
+            self.__client.execute = transform_result(self, self.__client.query)
+            self.__client.format = self.format
+
+    def __enter__(self):
+        return self.__client
+
+    def format(self, query, parameters=None):
+        if parameters:
+            ctx = QueryContext(query=query, parameters=parameters)
+            return ctx.final_query
+        return query
+
+    def __exit__(self, *args):
+        if config('CH_POOL', cast=bool, default=True):
+            CH_pool.release_connection(self.__client)
+        else:
+            self.__client.close()
+
+
+async def init():
+    logger.info(f">use CH_POOL:{config('CH_POOL', default=True)}")
+    if config('CH_POOL', cast=bool, default=True):
+        make_pool()
+
+
+async def terminate():
+    global CH_pool
+    if CH_pool is not None:
+        try:
+            CH_pool.close_all()
+            logger.info("Closed all connexions to CH")
+        except Exception as error:
+            logger.error("Error while closing all connexions to CH", exc_info=error)

api/chalicelib/utils/sql_helper.py

@@ -4,37 +4,41 @@ import schemas
 
 
 def get_sql_operator(op: Union[schemas.SearchEventOperator, schemas.ClickEventExtraOperator, schemas.MathOperator]):
+    if isinstance(op, Enum):
+        op = op.value
     return {
-        schemas.SearchEventOperator.IS: "=",
-        schemas.SearchEventOperator.ON: "=",
-        schemas.SearchEventOperator.ON_ANY: "IN",
-        schemas.SearchEventOperator.IS_NOT: "!=",
-        schemas.SearchEventOperator.NOT_ON: "!=",
-        schemas.SearchEventOperator.CONTAINS: "ILIKE",
-        schemas.SearchEventOperator.NOT_CONTAINS: "NOT ILIKE",
-        schemas.SearchEventOperator.STARTS_WITH: "ILIKE",
-        schemas.SearchEventOperator.ENDS_WITH: "ILIKE",
+        schemas.SearchEventOperator.IS.value: "=",
+        schemas.SearchEventOperator.ON.value: "=",
+        schemas.SearchEventOperator.ON_ANY.value: "IN",
+        schemas.SearchEventOperator.IS_NOT.value: "!=",
+        schemas.SearchEventOperator.NOT_ON.value: "!=",
+        schemas.SearchEventOperator.CONTAINS.value: "ILIKE",
+        schemas.SearchEventOperator.NOT_CONTAINS.value: "NOT ILIKE",
+        schemas.SearchEventOperator.STARTS_WITH.value: "ILIKE",
+        schemas.SearchEventOperator.ENDS_WITH.value: "ILIKE",
         # Selector operators:
-        schemas.ClickEventExtraOperator.IS: "=",
-        schemas.ClickEventExtraOperator.IS_NOT: "!=",
-        schemas.ClickEventExtraOperator.CONTAINS: "ILIKE",
-        schemas.ClickEventExtraOperator.NOT_CONTAINS: "NOT ILIKE",
-        schemas.ClickEventExtraOperator.STARTS_WITH: "ILIKE",
-        schemas.ClickEventExtraOperator.ENDS_WITH: "ILIKE",
+        schemas.ClickEventExtraOperator.IS.value: "=",
+        schemas.ClickEventExtraOperator.IS_NOT.value: "!=",
+        schemas.ClickEventExtraOperator.CONTAINS.value: "ILIKE",
+        schemas.ClickEventExtraOperator.NOT_CONTAINS.value: "NOT ILIKE",
+        schemas.ClickEventExtraOperator.STARTS_WITH.value: "ILIKE",
+        schemas.ClickEventExtraOperator.ENDS_WITH.value: "ILIKE",
 
-        schemas.MathOperator.GREATER: ">",
-        schemas.MathOperator.GREATER_EQ: ">=",
-        schemas.MathOperator.LESS: "<",
-        schemas.MathOperator.LESS_EQ: "<=",
+        schemas.MathOperator.GREATER.value: ">",
+        schemas.MathOperator.GREATER_EQ.value: ">=",
+        schemas.MathOperator.LESS.value: "<",
+        schemas.MathOperator.LESS_EQ.value: "<=",
     }.get(op, "=")
 
 
 def is_negation_operator(op: schemas.SearchEventOperator):
-    return op in [schemas.SearchEventOperator.IS_NOT,
-                  schemas.SearchEventOperator.NOT_ON,
-                  schemas.SearchEventOperator.NOT_CONTAINS,
-                  schemas.ClickEventExtraOperator.IS_NOT,
-                  schemas.ClickEventExtraOperator.NOT_CONTAINS]
+    if isinstance(op, Enum):
+        op = op.value
+    return op in [schemas.SearchEventOperator.IS_NOT.value,
+                  schemas.SearchEventOperator.NOT_ON.value,
+                  schemas.SearchEventOperator.NOT_CONTAINS.value,
+                  schemas.ClickEventExtraOperator.IS_NOT.value,
+                  schemas.ClickEventExtraOperator.NOT_CONTAINS.value]
 
 
 def reverse_sql_operator(op):

api/env.default

@@ -74,5 +74,4 @@ EXP_CH_DRIVER=true
 EXP_AUTOCOMPLETE=true
 EXP_ALERTS=true
 EXP_ERRORS_SEARCH=true
-EXP_METRICS=true
-EXP_SESSIONS_SEARCH=true
+EXP_METRICS=true

api/requirements-alerts.txt

@@ -1,15 +1,16 @@
 urllib3==2.3.0
 requests==2.32.3
-boto3==1.37.16
+boto3==1.36.12
 pyjwt==2.10.1
 psycopg2-binary==2.9.10
-psycopg[pool,binary]==3.2.6
+psycopg[pool,binary]==3.2.4
+clickhouse-driver[lz4]==0.2.9
 clickhouse-connect==0.8.15
-elasticsearch==8.17.2
+elasticsearch==8.17.1
 jira==3.8.0
-cachetools==5.5.2
+cachetools==5.5.1
 
-fastapi==0.115.11
+fastapi==0.115.8
 uvicorn[standard]==0.34.0
 python-decouple==3.8
 pydantic[email]==2.10.6

api/requirements.txt

@@ -1,15 +1,16 @@
 urllib3==2.3.0
 requests==2.32.3
-boto3==1.37.16
+boto3==1.36.12
 pyjwt==2.10.1
 psycopg2-binary==2.9.10
-psycopg[pool,binary]==3.2.6
+psycopg[pool,binary]==3.2.4
+clickhouse-driver[lz4]==0.2.9
 clickhouse-connect==0.8.15
-elasticsearch==8.17.2
+elasticsearch==8.17.1
 jira==3.8.0
-cachetools==5.5.2
+cachetools==5.5.1
 
-fastapi==0.115.11
+fastapi==0.115.8
 uvicorn[standard]==0.34.0
 python-decouple==3.8
 pydantic[email]==2.10.6

api/routers/subs/product_analytics.py

@@ -1,28 +0,0 @@
-import schemas
-from chalicelib.core.product_analytics import events, properties
-from fastapi import Depends
-from or_dependencies import OR_context
-from routers.base import get_routers
-from fastapi import Body, Depends, BackgroundTasks
-
-public_app, app, app_apikey = get_routers()
-
-
-@app.get('/{projectId}/properties/search', tags=["product_analytics"])
-def get_event_properties(projectId: int, event_name: str = None,
-                         context: schemas.CurrentContext = Depends(OR_context)):
-    if not event_name or len(event_name) == 0:
-        return {"data": []}
-    return {"data": properties.get_properties(project_id=projectId, event_name=event_name)}
-
-
-@app.get('/{projectId}/events/names', tags=["product_analytics"])
-def get_all_events(projectId: int,
-                   context: schemas.CurrentContext = Depends(OR_context)):
-    return {"data": events.get_events(project_id=projectId)}
-
-
-@app.post('/{projectId}/events/search', tags=["product_analytics"])
-def search_events(projectId: int, data: schemas.EventsSearchPayloadSchema = Body(...),
-                  context: schemas.CurrentContext = Depends(OR_context)):
-    return {"data": events.search_events(project_id=projectId, data=data)}

api/routers/subs/product_anaytics.py

@@ -0,0 +1,15 @@
+import schemas
+from chalicelib.core.metrics import product_anaytics2
+from fastapi import Depends
+from or_dependencies import OR_context
+from routers.base import get_routers
+
+
+public_app, app, app_apikey = get_routers()
+
+
+@app.post('/{projectId}/events/search', tags=["dashboard"])
+def search_events(projectId: int,
+                  # data: schemas.CreateDashboardSchema = Body(...),
+                  context: schemas.CurrentContext = Depends(OR_context)):
+    return product_anaytics2.search_events(project_id=projectId, data={})

api/schemas/__init__.py

@@ -1,3 +1,2 @@
 from .schemas import *
-from .product_analytics import *
 from . import overrides as _overrides

api/schemas/product_analytics.py

@@ -1,19 +0,0 @@
-from typing import Optional, List
-
-from pydantic import Field
-
-from .overrides import BaseModel
-from .schemas import EventPropertiesSchema, SortOrderType, _TimedSchema, \
-    _PaginatedSchema, PropertyFilterSchema
-
-
-class EventSearchSchema(BaseModel):
-    event_name: str = Field(...)
-    properties: Optional[EventPropertiesSchema] = Field(default=None)
-
-
-class EventsSearchPayloadSchema(_TimedSchema, _PaginatedSchema):
-    events: List[EventSearchSchema] = Field(default_factory=list, description="operator between events is OR")
-    filters: List[PropertyFilterSchema] = Field(default_factory=list, description="operator between filters is AND")
-    sort: str = Field(default="startTs")
-    order: SortOrderType = Field(default=SortOrderType.DESC)

api/schemas/schemas.py

@@ -545,70 +545,6 @@ class RequestGraphqlFilterSchema(BaseModel):
         return values
 
 
-class EventPredefinedPropertyType(str, Enum):
-    TIME = "$time"
-    SOURCE = "$source"
-    DURATION_S = "$duration_s"
-    DESCRIPTION = "description"
-    AUTO_CAPTURED = "$auto_captured"
-    SDK_EDITION = "$sdk_edition"
-    SDK_VERSION = "$sdk_version"
-    DEVICE_ID = "$device_id"
-    OS = "$os"
-    OS_VERSION = "$os_version"
-    BROWSER = "$browser"
-    BROWSER_VERSION = "$browser_version"
-    DEVICE = "$device"
-    SCREEN_HEIGHT = "$screen_height"
-    SCREEN_WIDTH = "$screen_width"
-    CURRENT_URL = "$current_url"
-    INITIAL_REFERRER = "$initial_referrer"
-    REFERRING_DOMAIN = "$referring_domain"
-    REFERRER = "$referrer"
-    INITIAL_REFERRING_DOMAIN = "$initial_referring_domain"
-    SEARCH_ENGINE = "$search_engine"
-    SEARCH_ENGINE_KEYWORD = "$search_engine_keyword"
-    UTM_SOURCE = "utm_source"
-    UTM_MEDIUM = "utm_medium"
-    UTM_CAMPAIGN = "utm_campaign"
-    COUNTRY = "$country"
-    STATE = "$state"
-    CITY = "$city"
-    ISSUE_TYPE = "issue_type"
-    TAGS = "$tags"
-    IMPORT = "$import"
-
-
-class PropertyFilterSchema(BaseModel):
-    name: Union[EventPredefinedPropertyType, str] = Field(...)
-    operator: Union[SearchEventOperator, MathOperator] = Field(...)
-    value: List[Union[int, str]] = Field(...)
-    property_type: Optional[Literal["string", "number", "date"]] = Field(default=None)
-
-    @computed_field
-    @property
-    def is_predefined(self) -> bool:
-        return EventPredefinedPropertyType.has_value(self.name)
-
-    @model_validator(mode="after")
-    def transform_name(self):
-        if isinstance(self.name, Enum):
-            self.name = self.name.value
-        return self
-
-
-class EventPropertiesSchema(BaseModel):
-    operators: List[Literal["and", "or"]] = Field(...)
-    filters: List[PropertyFilterSchema] = Field(...)
-
-    @model_validator(mode="after")
-    def event_filter_validator(self):
-        assert len(self.filters) == 0 \
-               or len(self.operators) == len(self.filters) - 1, \
-            "Number of operators must match the number of filter-1"
-        return self
-
-
 class SessionSearchEventSchema2(BaseModel):
     is_event: Literal[True] = True
     value: List[Union[str, int]] = Field(...)
@@ -617,7 +553,6 @@ class SessionSearchEventSchema2(BaseModel):
     source: Optional[List[Union[ErrorSource, int, str]]] = Field(default=None)
     sourceOperator: Optional[MathOperator] = Field(default=None)
     filters: Optional[List[RequestGraphqlFilterSchema]] = Field(default_factory=list)
-    properties: Optional[EventPropertiesSchema] = Field(default=None)
 
     _remove_duplicate_values = field_validator('value', mode='before')(remove_duplicate_values)
     _single_to_list_values = field_validator('value', mode='before')(single_to_list)
@@ -1025,36 +960,6 @@ class CardSessionsSchema(_TimedSchema, _PaginatedSchema):
 
         return self
 
-    # We don't need this as the UI is expecting filters to override the full series' filters
-    # @model_validator(mode="after")
-    # def __merge_out_filters_with_series(self):
-    #     for f in self.filters:
-    #         for s in self.series:
-    #             found = False
-    #
-    #             if f.is_event:
-    #                 sub = s.filter.events
-    #             else:
-    #                 sub = s.filter.filters
-    #
-    #             for e in sub:
-    #                 if f.type == e.type and f.operator == e.operator:
-    #                     found = True
-    #                     if f.is_event:
-    #                         # If extra event: append value
-    #                         for v in f.value:
-    #                             if v not in e.value:
-    #                                 e.value.append(v)
-    #                     else:
-    #                         # If extra filter: override value
-    #                         e.value = f.value
-    #             if not found:
-    #                 sub.append(f)
-    #
-    #     self.filters = []
-    #
-    #     return self
-
     # UI is expecting filters to override the full series' filters
     @model_validator(mode="after")
     def __override_series_filters_with_outer_filters(self):
@@ -1125,6 +1030,16 @@ class CardTable(__CardSchema):
             values["metricValue"] = []
         return values
 
+    @model_validator(mode="after")
+    def __enforce_AND_operator(self):
+        self.metric_of = MetricOfTable(self.metric_of)
+        if self.metric_of in (MetricOfTable.VISITED_URL, MetricOfTable.FETCH, \
+                              MetricOfTable.VISITED_URL.value, MetricOfTable.FETCH.value):
+            for s in self.series:
+                if s.filter is not None:
+                    s.filter.events_order = SearchEventOrder.AND
+        return self
+
     @model_validator(mode="after")
     def __transform(self):
         self.metric_of = MetricOfTable(self.metric_of)
@@ -1200,7 +1115,7 @@ class CardPathAnalysis(__CardSchema):
     view_type: MetricOtherViewType = Field(...)
     metric_value: List[ProductAnalyticsSelectedEventType] = Field(default_factory=list)
     density: int = Field(default=4, ge=2, le=10)
-    rows: int = Field(default=3, ge=1, le=10)
+    rows: int = Field(default=5, ge=1, le=10)
 
     start_type: Literal["start", "end"] = Field(default="start")
     start_point: List[PathAnalysisSubFilterSchema] = Field(default_factory=list)
@@ -1594,30 +1509,3 @@ class TagCreate(TagUpdate):
 
 class ScopeSchema(BaseModel):
     scope: int = Field(default=1, ge=1, le=2)
-
-
-class SessionModel(BaseModel):
-    duration: int
-    errorsCount: int
-    eventsCount: int
-    favorite: bool = Field(default=False)
-    issueScore: int
-    issueTypes: List[IssueType] = Field(default=[])
-    metadata: dict = Field(default={})
-    pagesCount: int
-    platform: str
-    projectId: int
-    sessionId: str
-    startTs: int
-    timezone: Optional[str]
-    userAnonymousId: Optional[str]
-    userBrowser: str
-    userCity: str
-    userCountry: str
-    userDevice: Optional[str]
-    userDeviceType: str
-    userId: Optional[str]
-    userOs: str
-    userState: str
-    userUuid: str
-    viewed: bool = Field(default=False)

assist/utils/assistHelper.js

@@ -19,14 +19,16 @@ const EVENTS_DEFINITION = {
     }
 };
 EVENTS_DEFINITION.emit = {
-    NEW_AGENT: "NEW_AGENT",
-    NO_AGENTS: "NO_AGENT",
-    AGENT_DISCONNECT: "AGENT_DISCONNECTED",
-    AGENTS_CONNECTED: "AGENTS_CONNECTED",
-    NO_SESSIONS: "SESSION_DISCONNECTED",
-    SESSION_ALREADY_CONNECTED: "SESSION_ALREADY_CONNECTED",
-    SESSION_RECONNECTED: "SESSION_RECONNECTED",
-    UPDATE_EVENT: EVENTS_DEFINITION.listen.UPDATE_EVENT
+  NEW_AGENT: "NEW_AGENT",
+  NO_AGENTS: "NO_AGENT",
+  AGENT_DISCONNECT: "AGENT_DISCONNECTED",
+  AGENTS_CONNECTED: "AGENTS_CONNECTED",
+  AGENTS_INFO_CONNECTED: "AGENTS_INFO_CONNECTED",
+  NO_SESSIONS: "SESSION_DISCONNECTED",
+  SESSION_ALREADY_CONNECTED: "SESSION_ALREADY_CONNECTED",
+  SESSION_RECONNECTED: "SESSION_RECONNECTED",
+  UPDATE_EVENT: EVENTS_DEFINITION.listen.UPDATE_EVENT,
+  WEBRTC_CONFIG: "WEBRTC_CONFIG",
 };
 
 const BASE_sessionInfo = {

assist/utils/extractors.js

@@ -1,11 +1,13 @@
 const {
     extractProjectKeyFromRequest,
     extractSessionIdFromRequest,
-    extractPayloadFromRequest
+    extractPayloadFromRequest,
+    getAvailableRooms
 } = require("./helper");
 
 module.exports = {
     extractProjectKeyFromRequest,
     extractSessionIdFromRequest,
-    extractPayloadFromRequest
+    extractPayloadFromRequest,
+    getAvailableRooms
 }

assist/utils/helper.js

@@ -261,6 +261,10 @@ const uniqueAutocomplete = function (list) {
     return _list;
 }
 
+const getAvailableRooms = async function (io) {
+    return io.sockets.adapter.rooms;
+}
+
 const getCompressionConfig = function () {
     // WS: The theoretical overhead per socket is 19KB (11KB for compressor and 8KB for decompressor)
     let perMessageDeflate = false;
@@ -301,5 +305,6 @@ module.exports = {
     extractPayloadFromRequest,
     sortPaginate,
     uniqueAutocomplete,
+    getAvailableRooms,
     getCompressionConfig
 };

assist/utils/httpHandlers.js

@@ -41,8 +41,8 @@ const respond = function (req, res, data) {
     RecordRequestDuration(req.method.toLowerCase(), res.handlerName, 200, duration/1000.0);
 }
 
-const getParticularSession = async function (roomId, filters, all=false) {
-    let connected_sockets = await fetchSockets(roomId, all);
+const getParticularSession = async function (roomId, filters) {
+    let connected_sockets = await fetchSockets(roomId);
     if (connected_sockets.length === 0) {
         return null;
     }
@@ -172,7 +172,7 @@ const socketsLiveBySession = async function (req, res) {
 
     // find a particular session
     if (_sessionId) {
-        let sessInfo = await getParticularSession(`${_projectKey}-${_sessionId}`, filters, true);
+        let sessInfo = await getParticularSession(`${_projectKey}-${_sessionId}`, filters);
         return respond(req, res, sessInfo);
     }
     return respond(req, res, null);

assist/utils/socketHandlers.js

@@ -13,9 +13,7 @@ const {
     handleEvent
 } = require("./stats");
 const {
-    sendTo,
-    sendFrom,
-    fetchSockets
+    getServer
 } = require('../utils/wsServer');
 const {
     IncreaseTotalWSConnections,
@@ -28,9 +26,9 @@ const {
 const {logger} = require('./logger');
 const deepMerge = require('@fastify/deepmerge')({all: true});
 
-const findSessionSocketId = async (roomId, tabId) => {
+const findSessionSocketId = async (io, roomId, tabId) => {
     let pickFirstSession = tabId === undefined;
-    const connected_sockets = await fetchSockets(roomId);
+    const connected_sockets = await io.in(roomId).fetchSockets();
     for (let socket of connected_sockets) {
         if (socket.handshake.query.identity === IDENTITIES.session) {
             if (pickFirstSession) {
@@ -43,9 +41,9 @@ const findSessionSocketId = async (roomId, tabId) => {
     return null;
 };
 
-async function getRoomData(roomID) {
-    let tabsCount = 0, agentsCount = 0, tabIDs = [], agentIDs = [];
-    const connected_sockets = await fetchSockets(roomID);
+async function getRoomData(io, roomID) {
+    let tabsCount = 0, agentsCount = 0, tabIDs = [], agentIDs = [], config = null, agentInfos = [];
+    const connected_sockets = await io.in(roomID).fetchSockets();
     if (connected_sockets.length > 0) {
         for (let socket of connected_sockets) {
             if (socket.handshake.query.identity === IDENTITIES.session) {
@@ -54,13 +52,19 @@ async function getRoomData(roomID) {
             } else {
                 agentsCount++;
                 agentIDs.push(socket.id);
+                agentInfos.push({ ...socket.handshake.query.agentInfo, socketId: socket.id });
+                if (socket.handshake.query.config !== undefined) {
+                    config = socket.handshake.query.config;
+                }
             }
         }
     } else {
         tabsCount = -1;
         agentsCount = -1;
+        agentInfos = [];
+        agentIDs = [];
     }
-    return {tabsCount, agentsCount, tabIDs, agentIDs};
+    return {tabsCount, agentsCount, tabIDs, agentIDs, config, agentInfos};
 }
 
 function processNewSocket(socket) {
@@ -79,7 +83,8 @@ async function onConnect(socket) {
     IncreaseTotalWSConnections(socket.handshake.query.identity);
     IncreaseOnlineConnections(socket.handshake.query.identity);
 
-    const {tabsCount, agentsCount, tabIDs, agentIDs} = await getRoomData(socket.handshake.query.roomId);
+    const io = getServer();
+    const {tabsCount, agentsCount, tabIDs, agentInfos, agentIDs, config} = await getRoomData(io, socket.handshake.query.roomId);
 
     if (socket.handshake.query.identity === IDENTITIES.session) {
         // Check if session with the same tabID already connected, if so, refuse new connexion
@@ -87,7 +92,7 @@ async function onConnect(socket) {
             for (let tab of tabIDs) {
                 if (tab === socket.handshake.query.tabId) {
                     logger.debug(`session already connected, refusing new connexion, peerId: ${socket.handshake.query.peerId}`);
-                    sendTo(socket.id, EVENTS_DEFINITION.emit.SESSION_ALREADY_CONNECTED);
+                    io.to(socket.id).emit(EVENTS_DEFINITION.emit.SESSION_ALREADY_CONNECTED);
                     return socket.disconnect();
                 }
             }
@@ -101,12 +106,14 @@ async function onConnect(socket) {
         // Inform all connected agents about reconnected session
         if (agentsCount > 0) {
             logger.debug(`notifying new session about agent-existence`);
-            sendTo(socket.id, EVENTS_DEFINITION.emit.AGENTS_CONNECTED, agentIDs);
-            sendFrom(socket, socket.handshake.query.roomId, EVENTS_DEFINITION.emit.SESSION_RECONNECTED, socket.id);
+            io.to(socket.id).emit(EVENTS_DEFINITION.emit.WEBRTC_CONFIG, config);
+            io.to(socket.id).emit(EVENTS_DEFINITION.emit.AGENTS_CONNECTED, agentIDs);
+            io.to(socket.id).emit(EVENTS_DEFINITION.emit.AGENTS_INFO_CONNECTED, agentInfos);
+            socket.to(socket.handshake.query.roomId).emit(EVENTS_DEFINITION.emit.SESSION_RECONNECTED, socket.id);
         }
     } else if (tabsCount <= 0) {
         logger.debug(`notifying new agent about no SESSIONS with peerId:${socket.handshake.query.peerId}`);
-        sendTo(socket.id, EVENTS_DEFINITION.emit.NO_SESSIONS);
+        io.to(socket.id).emit(EVENTS_DEFINITION.emit.NO_SESSIONS);
     }
     await socket.join(socket.handshake.query.roomId);
 
@@ -119,7 +126,8 @@ async function onConnect(socket) {
             // Stats
             startAssist(socket, socket.handshake.query.agentID);
         }
-        sendFrom(socket, socket.handshake.query.roomId, EVENTS_DEFINITION.emit.NEW_AGENT, socket.id, socket.handshake.query.agentInfo);
+        io.to(socket.handshake.query.roomId).emit(EVENTS_DEFINITION.emit.WEBRTC_CONFIG, socket.handshake.query.config);
+        socket.to(socket.handshake.query.roomId).emit(EVENTS_DEFINITION.emit.NEW_AGENT, socket.id, { ...socket.handshake.query.agentInfo });
     }
 
     // Set disconnect handler
@@ -145,12 +153,13 @@ async function onDisconnect(socket) {
     logger.debug(`${socket.id} disconnected from ${socket.handshake.query.roomId}`);
 
     if (socket.handshake.query.identity === IDENTITIES.agent) {
-        sendFrom(socket, socket.handshake.query.roomId, EVENTS_DEFINITION.emit.AGENT_DISCONNECT, socket.id);
+        socket.to(socket.handshake.query.roomId).emit(EVENTS_DEFINITION.emit.AGENT_DISCONNECT, socket.id);
         // Stats
         endAssist(socket, socket.handshake.query.agentID);
     }
     logger.debug("checking for number of connected agents and sessions");
-    let {tabsCount, agentsCount, tabIDs, agentIDs} = await getRoomData(socket.handshake.query.roomId);
+    const io = getServer();
+    let {tabsCount, agentsCount, tabIDs, agentIDs} = await getRoomData(io, socket.handshake.query.roomId);
 
     if (tabsCount === -1 && agentsCount === -1) {
         DecreaseOnlineRooms();
@@ -159,11 +168,11 @@ async function onDisconnect(socket) {
     }
     if (tabsCount === 0) {
         logger.debug(`notifying everyone in ${socket.handshake.query.roomId} about no SESSIONS`);
-        sendFrom(socket, socket.handshake.query.roomId, EVENTS_DEFINITION.emit.NO_SESSIONS);
+        socket.to(socket.handshake.query.roomId).emit(EVENTS_DEFINITION.emit.NO_SESSIONS);
     }
     if (agentsCount === 0) {
         logger.debug(`notifying everyone in ${socket.handshake.query.roomId} about no AGENTS`);
-        sendFrom(socket, socket.handshake.query.roomId, EVENTS_DEFINITION.emit.NO_AGENTS);
+        socket.to(socket.handshake.query.roomId).emit(EVENTS_DEFINITION.emit.NO_AGENTS);
     }
 }
 
@@ -178,12 +187,13 @@ async function onUpdateEvent(socket, ...args) {
     socket.handshake.query.sessionInfo = deepMerge(socket.handshake.query.sessionInfo, args[0]?.data, {tabId: args[0]?.meta?.tabId});
 
     // Update sessionInfo for all agents in the room
-    const connected_sockets = await fetchSockets(socket.handshake.query.roomId);
+    const io = getServer();
+    const connected_sockets = await io.in(socket.handshake.query.roomId).fetchSockets();
     for (let item of connected_sockets) {
         if (item.handshake.query.identity === IDENTITIES.session && item.handshake.query.sessionInfo) {
             item.handshake.query.sessionInfo = deepMerge(item.handshake.query.sessionInfo, args[0]?.data, {tabId: args[0]?.meta?.tabId});
         } else if (item.handshake.query.identity === IDENTITIES.agent) {
-            sendFrom(socket, item.id, EVENTS_DEFINITION.emit.UPDATE_EVENT, args[0]);
+            socket.to(item.id).emit(EVENTS_DEFINITION.listen.UPDATE_EVENT, args[0]);
         }
     }
 }
@@ -193,7 +203,7 @@ async function onWebrtcAgentHandler(socket, ...args) {
         const agentIdToConnect = args[0]?.data?.toAgentId;
         logger.debug(`${socket.id} sent webrtc event to agent:${agentIdToConnect}`);
         if (agentIdToConnect && socket.handshake.sessionData.AGENTS_CONNECTED.includes(agentIdToConnect)) {
-            sendFrom(socket, agentIdToConnect, EVENTS_DEFINITION.listen.WEBRTC_AGENT_CALL, args[0]);
+            socket.to(agentIdToConnect).emit(EVENTS_DEFINITION.listen.WEBRTC_AGENT_CALL, args[0]);
         }
     }
 }
@@ -206,18 +216,19 @@ async function onAny(socket, eventName, ...args) {
     args[0] = updateSessionData(socket, args[0])
     if (socket.handshake.query.identity === IDENTITIES.session) {
         logger.debug(`received event:${eventName}, from:${socket.handshake.query.identity}, sending message to room:${socket.handshake.query.roomId}`);
-        sendFrom(socket, socket.handshake.query.roomId, eventName, args[0]);
+        socket.to(socket.handshake.query.roomId).emit(eventName, args[0]);
     } else {
         // Stats
         handleEvent(eventName, socket, args[0]);
         logger.debug(`received event:${eventName}, from:${socket.handshake.query.identity}, sending message to session of room:${socket.handshake.query.roomId}`);
-        let socketId = await findSessionSocketId(socket.handshake.query.roomId, args[0]?.meta?.tabId);
+        const io = getServer();
+        let socketId = await findSessionSocketId(io, socket.handshake.query.roomId, args[0]?.meta?.tabId);
         if (socketId === null) {
             logger.debug(`session not found for:${socket.handshake.query.roomId}`);
-            sendTo(socket.id, EVENTS_DEFINITION.emit.NO_SESSIONS);
+            io.to(socket.id).emit(EVENTS_DEFINITION.emit.NO_SESSIONS);
         } else {
             logger.debug("message sent");
-            sendTo(socket.id, eventName, socket.id, args[0]);
+            io.to(socketId).emit(eventName, socket.id, args[0]);
         }
     }
 }
@@ -232,4 +243,4 @@ function updateSessionData(socket, sessionData) {
 
 module.exports = {
     onConnect,
-}
+}

assist/utils/wsServer.js

@@ -3,15 +3,11 @@ const {getCompressionConfig} = require("./helper");
 
 let io;
 
-function sendFrom(from, to, eventName, ...data) {
-    from.to(to).emit(eventName, ...data);
+const getServer = function () {
+    return io;
 }
 
-function sendTo(to, eventName, ...data) {
-    sendFrom(io, to, eventName, ...data);
-}
-
-const fetchSockets = async function (roomID, all=false) {
+const fetchSockets = async function (roomID) {
     if (!io) {
         return [];
     }
@@ -39,7 +35,6 @@ const createSocketIOServer = function (server, prefix) {
 
 module.exports = {
     createSocketIOServer,
-    sendTo,
-    sendFrom,
+    getServer,
     fetchSockets,
 }

backend/internal/db/datasaver/saver.go

@@ -2,11 +2,12 @@ package datasaver
 
 import (
 	"context"
+	"encoding/json"
+	"openreplay/backend/pkg/db/types"
 
 	"openreplay/backend/internal/config/db"
 	"openreplay/backend/pkg/db/clickhouse"
 	"openreplay/backend/pkg/db/postgres"
-	"openreplay/backend/pkg/db/types"
 	"openreplay/backend/pkg/logger"
 	. "openreplay/backend/pkg/messages"
 	queue "openreplay/backend/pkg/queue/types"
@@ -50,10 +51,6 @@ func New(log logger.Logger, cfg *db.Config, pg *postgres.Conn, ch clickhouse.Con
 }
 
 func (s *saverImpl) Handle(msg Message) {
-	if msg.TypeID() == MsgCustomEvent {
-		defer s.Handle(types.WrapCustomEvent(msg.(*CustomEvent)))
-	}
-
 	var (
 		sessCtx = context.WithValue(context.Background(), "sessionID", msg.SessionID())
 		session *sessions.Session
@@ -69,6 +66,23 @@ func (s *saverImpl) Handle(msg Message) {
 		return
 	}
 
+	if msg.TypeID() == MsgCustomEvent {
+		m := msg.(*CustomEvent)
+		// Try to parse custom event payload to JSON and extract or_payload field
+		type CustomEventPayload struct {
+			CustomTimestamp uint64 `json:"or_timestamp"`
+		}
+		customPayload := &CustomEventPayload{}
+		if err := json.Unmarshal([]byte(m.Payload), customPayload); err == nil {
+			if customPayload.CustomTimestamp >= session.Timestamp {
+				s.log.Info(sessCtx, "custom event timestamp received: %v", m.Timestamp)
+				msg.Meta().Timestamp = customPayload.CustomTimestamp
+				s.log.Info(sessCtx, "custom event timestamp updated: %v", m.Timestamp)
+			}
+		}
+		defer s.Handle(types.WrapCustomEvent(m))
+	}
+
 	if IsMobileType(msg.TypeID()) {
 		if err := s.handleMobileMessage(sessCtx, session, msg); err != nil {
 			if !postgres.IsPkeyViolation(err) {

backend/pkg/sessions/api/web/handlers.go

@@ -135,6 +135,11 @@ func (e *handlersImpl) startSessionHandlerWeb(w http.ResponseWriter, r *http.Req
 
 	// Add tracker version to context
 	r = r.WithContext(context.WithValue(r.Context(), "tracker", req.TrackerVersion))
+	if err := validateTrackerVersion(req.TrackerVersion); err != nil {
+		e.log.Error(r.Context(), "unsupported tracker version: %s, err: %s", req.TrackerVersion, err)
+		e.responser.ResponseWithError(e.log, r.Context(), w, http.StatusUpgradeRequired, errors.New("please upgrade the tracker version"), startTime, r.URL.Path, bodySize)
+		return
+	}
 
 	// Handler's logic
 	if req.ProjectKey == nil {
@@ -157,13 +162,6 @@ func (e *handlersImpl) startSessionHandlerWeb(w http.ResponseWriter, r *http.Req
 	// Add projectID to context
 	r = r.WithContext(context.WithValue(r.Context(), "projectID", fmt.Sprintf("%d", p.ProjectID)))
 
-	// Validate tracker version
-	if err := validateTrackerVersion(req.TrackerVersion); err != nil {
-		e.log.Error(r.Context(), "unsupported tracker version: %s, err: %s", req.TrackerVersion, err)
-		e.responser.ResponseWithError(e.log, r.Context(), w, http.StatusUpgradeRequired, errors.New("please upgrade the tracker version"), startTime, r.URL.Path, bodySize)
-		return
-	}
-
 	// Check if the project supports mobile sessions
 	if !p.IsWeb() {
 		e.responser.ResponseWithError(e.log, r.Context(), w, http.StatusForbidden, errors.New("project doesn't support web sessions"), startTime, r.URL.Path, bodySize)

ee/api/.gitignore

@@ -223,14 +223,10 @@ Pipfile.lock
 /chalicelib/core/sessions/performance_event.py
 /chalicelib/core/sessions/sessions_viewed/sessions_viewed.py
 /chalicelib/core/sessions/unprocessed_sessions.py
-/chalicelib/core/sessions/__init__.py
-/chalicelib/core/sessions/sessions_legacy_mobil.py
-/chalicelib/core/sessions/sessions_search_exp.py
 /chalicelib/core/metrics/modules
 /chalicelib/core/socket_ios.py
 /chalicelib/core/sourcemaps
 /chalicelib/core/tags.py
-/chalicelib/core/product_analytics
 /chalicelib/saml
 /chalicelib/utils/__init__.py
 /chalicelib/utils/args_transformer.py
@@ -293,5 +289,3 @@ Pipfile.lock
 /chalicelib/core/errors/errors_ch.py
 /chalicelib/core/errors/errors_details.py
 /chalicelib/utils/contextual_validators.py
-/routers/subs/product_analytics.py
-/schemas/product_analytics.py

ee/api/Pipfile

@@ -6,20 +6,23 @@ name = "pypi"
 [packages]
 urllib3 = "==2.3.0"
 requests = "==2.32.3"
-boto3 = "==1.37.16"
+boto3 = "==1.36.12"
 pyjwt = "==2.10.1"
 psycopg2-binary = "==2.9.10"
-psycopg = {extras = ["binary", "pool"], version = "==3.2.6"}
+psycopg = {extras = ["pool", "binary"], version = "==3.2.4"}
+clickhouse-driver = {extras = ["lz4"], version = "==0.2.9"}
 clickhouse-connect = "==0.8.15"
-elasticsearch = "==8.17.2"
+elasticsearch = "==8.17.1"
 jira = "==3.8.0"
-cachetools = "==5.5.2"
-fastapi = "==0.115.11"
+cachetools = "==5.5.1"
+fastapi = "==0.115.8"
 uvicorn = {extras = ["standard"], version = "==0.34.0"}
 gunicorn = "==23.0.0"
 python-decouple = "==3.8"
 pydantic = {extras = ["email"], version = "==2.10.6"}
 apscheduler = "==3.11.0"
+python3-saml = "==1.16.0"
+python-multipart = "==0.0.20"
 redis = "==5.2.1"
 azure-storage-blob = "==12.24.1"
 

ee/api/app.py

@@ -21,7 +21,7 @@ from chalicelib.utils import pg_client, ch_client
 from crons import core_crons, ee_crons, core_dynamic_crons
 from routers import core, core_dynamic
 from routers import ee
-from routers.subs import insights, metrics, v1_api, health, usability_tests, spot, product_analytics
+from routers.subs import insights, metrics, v1_api, health, usability_tests, spot, product_anaytics
 from routers.subs import v1_api_ee
 
 if config("ENABLE_SSO", cast=bool, default=True):
@@ -150,9 +150,9 @@ app.include_router(spot.public_app)
 app.include_router(spot.app)
 app.include_router(spot.app_apikey)
 
-app.include_router(product_analytics.public_app, prefix="/ap")
-app.include_router(product_analytics.app, prefix="/ap")
-app.include_router(product_analytics.app_apikey, prefix="/ap")
+app.include_router(product_anaytics.public_app)
+app.include_router(product_anaytics.app)
+app.include_router(product_anaytics.app_apikey)
 
 if config("ENABLE_SSO", cast=bool, default=True):
     app.include_router(saml.public_app)

ee/api/chalicelib/core/autocomplete/autocomplete_ch.py

@@ -86,7 +86,8 @@ def __generic_query(typename, value_length=None):
                       ORDER BY value"""
 
     if value_length is None or value_length > 2:
-        return f"""(SELECT DISTINCT value, type
+        return f"""SELECT DISTINCT ON(value, type) value, type
+                   FROM ((SELECT DISTINCT value, type
                     FROM {TABLE}
                     WHERE
                       project_id = %(project_id)s
@@ -102,7 +103,7 @@ def __generic_query(typename, value_length=None):
                       AND type='{typename.upper()}'
                       AND value ILIKE %(value)s
                       ORDER BY value
-                    LIMIT 5);"""
+                    LIMIT 5)) AS raw;"""
     return f"""SELECT DISTINCT value, type
                 FROM {TABLE}
                 WHERE
@@ -257,7 +258,7 @@ def __search_metadata(project_id, value, key=None, source=None):
                                 WHERE project_id = %(project_id)s
                                 AND {colname} ILIKE %(svalue)s LIMIT 5)""")
     with ch_client.ClickHouseClient() as cur:
-        query = cur.format(query=f"""SELECT key, value, 'METADATA' AS TYPE
+        query = cur.format(query=f"""SELECT DISTINCT ON(key, value) key, value, 'METADATA' AS TYPE
                                 FROM({" UNION ALL ".join(sub_from)}) AS all_metas
                                 LIMIT 5;""", parameters={"project_id": project_id, "value": helper.string_to_sql_like(value),
                                               "svalue": helper.string_to_sql_like("^" + value)})

ee/api/chalicelib/core/errors/errors_details_exp.py

@@ -71,7 +71,7 @@ def get_details(project_id, error_id, user_id, **data):
     MAIN_EVENTS_TABLE = exp_ch_helper.get_main_events_table(0)
 
     ch_basic_query = errors_helper.__get_basic_constraints_ch(time_constraint=False)
-    ch_basic_query.append("toString(`$properties`.error_id) = %(error_id)s")
+    ch_basic_query.append("error_id = %(error_id)s")
 
     with ch_client.ClickHouseClient() as ch:
         data["startDate24"] = TimeUTC.now(-1)
@@ -95,7 +95,7 @@ def get_details(project_id, error_id, user_id, **data):
             "error_id": error_id}
 
         main_ch_query = f"""\
-        WITH pre_processed AS (SELECT toString(`$properties`.error_id)         AS error_id,
+        WITH pre_processed AS (SELECT error_id,
                                       toString(`$properties`.name)             AS name,
                                       toString(`$properties`.message)          AS message,
                                       session_id,
@@ -183,7 +183,7 @@ def get_details(project_id, error_id, user_id, **data):
                                          AND `$event_name` = 'ERROR'
                                          AND events.created_at >= toDateTime(timestamp / 1000)
                                          AND events.created_at < toDateTime((timestamp + %(step_size24)s) / 1000)
-                                         AND toString(`$properties`.error_id) = %(error_id)s
+                                         AND error_id = %(error_id)s
                                    GROUP BY timestamp
                                    ORDER BY timestamp) AS chart_details
                             ) AS chart_details24 ON TRUE
@@ -196,7 +196,7 @@ def get_details(project_id, error_id, user_id, **data):
                                          AND `$event_name` = 'ERROR'
                                          AND events.created_at >= toDateTime(timestamp / 1000)
                                          AND events.created_at < toDateTime((timestamp + %(step_size30)s) / 1000)
-                                         AND toString(`$properties`.error_id) = %(error_id)s
+                                         AND error_id = %(error_id)s
                                    GROUP BY timestamp
                                    ORDER BY timestamp) AS chart_details
                             ) AS chart_details30 ON TRUE;"""

ee/api/chalicelib/core/sessions/__init__.py

@@ -0,0 +1,17 @@
+import logging
+
+from decouple import config
+
+logger = logging.getLogger(__name__)
+from . import sessions_pg
+from . import sessions_pg as sessions_legacy
+from . import sessions_ch
+from . import sessions_search as sessions_search_legacy
+
+if config("EXP_SESSIONS_SEARCH", cast=bool, default=False):
+    logger.info(">>> Using experimental sessions search")
+    from . import sessions_ch as sessions
+    from . import sessions_search_exp as sessions_search
+else:
+    from . import sessions_pg as sessions
+    from . import sessions_search as sessions_search

ee/api/chalicelib/core/sessions/sessions_legacy_mobil.py

@@ -1,5 +1,6 @@
 import ast
 import logging
+from typing import List, Union
 
 import schemas
 from chalicelib.core import events, metadata, projects

ee/api/chalicelib/core/sessions/sessions_search_exp.py

@@ -175,11 +175,11 @@ def search_sessions(data: schemas.SessionsSearchPayloadSchema, project: schemas.
                                               ORDER BY sort_key {data.order}
                                               LIMIT %(sessions_limit)s OFFSET %(sessions_limit_s)s) AS sorted_sessions;""",
                                     parameters=full_args)
-
+        logging.debug("--------------------")
+        logging.debug(main_query)
+        logging.debug("--------------------")
         try:
-            logging.debug("--------------------")
             sessions_list = cur.execute(main_query)
-            logging.debug("--------------------")
         except Exception as err:
             logging.warning("--------- SESSIONS-CH SEARCH QUERY EXCEPTION -----------")
             logging.warning(main_query)

ee/api/chalicelib/core/users.py

@@ -927,12 +927,12 @@ def authenticate_sso(email: str, internal_id: str):
                                                              aud=AUDIENCE, jwt_jti=j_r.jwt_refresh_jti),
             "refreshTokenMaxAge": config("JWT_REFRESH_EXPIRATION", cast=int),
             "spotJwt": authorizers.generate_jwt(user_id=r['userId'], tenant_id=r['tenantId'],
-                                                iat=j_r.spot_jwt_iat, aud=spot.AUDIENCE),
+                                                iat=j_r.spot_jwt_iat, aud=spot.AUDIENCE, for_spot=True),
             "spotRefreshToken": authorizers.generate_jwt_refresh(user_id=r['userId'],
                                                                  tenant_id=r['tenantId'],
                                                                  iat=j_r.spot_jwt_refresh_iat,
                                                                  aud=spot.AUDIENCE,
-                                                                 jwt_jti=j_r.spot_jwt_refresh_jti),
+                                                                 jwt_jti=j_r.spot_jwt_refresh_jti, for_spot=True),
             "spotRefreshTokenMaxAge": config("JWT_SPOT_REFRESH_EXPIRATION", cast=int)
         }
         return response

ee/api/clean-dev.sh

@@ -44,15 +44,11 @@ rm -rf ./chalicelib/core/sessions/sessions_search.py
 rm -rf ./chalicelib/core/sessions/performance_event.py
 rm -rf ./chalicelib/core/sessions/sessions_viewed/sessions_viewed.py
 rm -rf ./chalicelib/core/sessions/unprocessed_sessions.py
-rm -rf ./chalicelib/core/sessions/__init__.py
-rm -rf ./chalicelib/core/sessions/sessions_legacy_mobil.py
-rm -rf ./chalicelib/core/sessions/sessions_search_exp.py
 rm -rf ./chalicelib/core/metrics/modules
 rm -rf ./chalicelib/core/socket_ios.py
 rm -rf ./chalicelib/core/sourcemaps
 rm -rf ./chalicelib/core/user_testing.py
 rm -rf ./chalicelib/core/tags.py
-rm -rf ./chalicelib/core/product_analytics
 rm -rf ./chalicelib/saml
 rm -rf ./chalicelib/utils/__init__.py
 rm -rf ./chalicelib/utils/args_transformer.py
@@ -113,5 +109,3 @@ rm -rf ./chalicelib/core/errors/errors_pg.py
 rm -rf ./chalicelib/core/errors/errors_ch.py
 rm -rf ./chalicelib/core/errors/errors_details.py
 rm -rf ./chalicelib/utils/contextual_validators.py
-rm -rf ./routers/subs/product_analytics.py
-rm -rf ./schemas/product_analytics.py

ee/api/requirements-alerts.txt

@@ -1,15 +1,16 @@
 urllib3==2.3.0
 requests==2.32.3
-boto3==1.37.16
+boto3==1.36.12
 pyjwt==2.10.1
 psycopg2-binary==2.9.10
-psycopg[pool,binary]==3.2.6
+psycopg[pool,binary]==3.2.4
+clickhouse-driver[lz4]==0.2.9
 clickhouse-connect==0.8.15
-elasticsearch==8.17.2
+elasticsearch==8.17.1
 jira==3.8.0
-cachetools==5.5.2
+cachetools==5.5.1
 
-fastapi==0.115.11
+fastapi==0.115.8
 uvicorn[standard]==0.34.0
 python-decouple==3.8
 pydantic[email]==2.10.6

ee/api/requirements-crons.txt

@@ -1,15 +1,16 @@
 urllib3==2.3.0
 requests==2.32.3
-boto3==1.37.16
+boto3==1.36.12
 pyjwt==2.10.1
 psycopg2-binary==2.9.10
-psycopg[pool,binary]==3.2.6
+psycopg[pool,binary]==3.2.4
+clickhouse-driver[lz4]==0.2.9
 clickhouse-connect==0.8.15
-elasticsearch==8.17.2
+elasticsearch==8.17.1
 jira==3.8.0
-cachetools==5.5.2
+cachetools==5.5.1
 
-fastapi==0.115.11
+fastapi==0.115.8
 python-decouple==3.8
 pydantic[email]==2.10.6
 apscheduler==3.11.0

ee/api/requirements.txt

@@ -1,15 +1,16 @@
 urllib3==2.3.0
 requests==2.32.3
-boto3==1.37.16
+boto3==1.36.12
 pyjwt==2.10.1
 psycopg2-binary==2.9.10
-psycopg[pool,binary]==3.2.6
+psycopg[pool,binary]==3.2.4
+clickhouse-driver[lz4]==0.2.9
 clickhouse-connect==0.8.15
-elasticsearch==8.17.2
+elasticsearch==8.17.1
 jira==3.8.0
-cachetools==5.5.2
+cachetools==5.5.1
 
-fastapi==0.115.11
+fastapi==0.115.8
 uvicorn[standard]==0.34.0
 gunicorn==23.0.0
 python-decouple==3.8

ee/api/schemas/__init__.py

@@ -1,5 +1,4 @@
 from .schemas import *
 from .schemas_ee import *
 from .assist_stats_schema import *
-from .product_analytics import *
 from . import overrides as _overrides

ee/api/schemas/schemas_ee.py

@@ -4,7 +4,7 @@ from pydantic import Field, EmailStr, field_validator, model_validator
 
 from chalicelib.utils.TimeUTC import TimeUTC
 from . import schemas
-from .overrides import BaseModel, Enum
+from .overrides import BaseModel, Enum, ORUnion
 from .transformers_validators import remove_whitespace
 
 
@@ -91,6 +91,33 @@ class TrailSearchPayloadSchema(schemas._PaginatedSchema):
         return values
 
 
+class SessionModel(BaseModel):
+    duration: int
+    errorsCount: int
+    eventsCount: int
+    favorite: bool = Field(default=False)
+    issueScore: int
+    issueTypes: List[schemas.IssueType] = Field(default=[])
+    metadata: dict = Field(default={})
+    pagesCount: int
+    platform: str
+    projectId: int
+    sessionId: str
+    startTs: int
+    timezone: Optional[str]
+    userAnonymousId: Optional[str]
+    userBrowser: str
+    userCity: str
+    userCountry: str
+    userDevice: Optional[str]
+    userDeviceType: str
+    userId: Optional[str]
+    userOs: str
+    userState: str
+    userUuid: str
+    viewed: bool = Field(default=False)
+
+
 class AssistRecordUpdatePayloadSchema(BaseModel):
     name: str = Field(..., min_length=1)
     _transform_name = field_validator('name', mode="before")(remove_whitespace)

ee/assist/.gitignore

@@ -15,7 +15,7 @@ servers/sourcemaps-server.js
 /utils/HeapSnapshot.js
 /utils/helper.js
 /utils/assistHelper.js
-#/utils/httpHandlers.js
-#/utils/socketHandlers.js
+/utils/httpHandlers.js
+/utils/socketHandlers.js
 .local
 *.mmdb

ee/assist/servers/websocket-cluster.js

@@ -21,9 +21,7 @@ const {createAdapter} = require("@socket.io/redis-adapter");
 const {createClient} = require("redis");
 const REDIS_URL = (process.env.REDIS_URL || "localhost:6379").replace(/((^\w+:|^)\/\/|^)/, 'redis://');
 const pubClient = createClient({url: REDIS_URL});
-pubClient.on("error", (error) => logger.error(`Pub redis client error : ${error}`));
 const subClient = pubClient.duplicate();
-subClient.on("error", (error) => logger.error(`Sub redis client error : ${error}`));
 logger.info(`Using Redis: ${REDIS_URL}`);
 
 const wsRouter = express.Router();
@@ -49,7 +47,7 @@ module.exports = {
         Promise.all([pubClient.connect(), subClient.connect()])
             .then(() => {
                 io.adapter(createAdapter(pubClient, subClient,
-                    {requestsTimeout: parseInt(process.env.REDIS_REQUESTS_TIMEOUT) || 10000}));
+                    {requestsTimeout: process.env.REDIS_REQUESTS_TIMEOUT || 5000}));
                 logger.info("> redis connected.");
             })
             .catch((err) => {

ee/assist/utils/extractors.js

@@ -1,11 +1,13 @@
 const {
     extractProjectKeyFromRequest,
     extractSessionIdFromRequest,
-    extractPayloadFromRequest
+    extractPayloadFromRequest,
+    getAvailableRooms
 } = require('../utils/helper-ee');
 
 module.exports = {
     extractProjectKeyFromRequest,
     extractSessionIdFromRequest,
-    extractPayloadFromRequest
+    extractPayloadFromRequest,
+    getAvailableRooms
 }

ee/assist/utils/helper-ee.js

@@ -91,7 +91,13 @@ const extractPayloadFromRequest = async function (req, res) {
     logger.debug("payload/filters:" + JSON.stringify(filters))
     return Object.keys(filters).length > 0 ? filters : undefined;
 }
-
+const getAvailableRooms = async function (io) {
+    if (process.env.redis === "true") {
+        return io.of('/').adapter.allRooms();
+    } else {
+        return helper.getAvailableRooms(io);
+    }
+}
 const getCompressionConfig = function () {
     if (process.env.uws !== "true") {
         return helper.getCompressionConfig();
@@ -115,5 +121,6 @@ module.exports = {
     extractProjectKeyFromRequest,
     extractSessionIdFromRequest,
     extractPayloadFromRequest,
-    getCompressionConfig
+    getCompressionConfig,
+    getAvailableRooms
 };

ee/assist/utils/httpHandlers.js

@@ -1,212 +0,0 @@
-const {
-    hasFilters,
-    hasQuery,
-    isValidSession,
-    sortPaginate,
-    getValidAttributes,
-    uniqueAutocomplete
-} = require("./helper");
-const {
-    extractProjectKeyFromRequest,
-    extractSessionIdFromRequest,
-    extractPayloadFromRequest,
-} = require("./extractors");
-const {
-    RecordRequestDuration,
-    IncreaseTotalRequests
-} = require('../utils/metrics');
-const {fetchSockets, getSessionFromCache} = require("./wsServer");
-const {IDENTITIES} = require("./assistHelper");
-const {logger} = require('./logger');
-
-const respond = function (req, res, data) {
-    logger.debug("responding with data: ", JSON.stringify(data))
-    let result = {data}
-    if (process.env.uws !== "true") {
-        res.statusCode = 200;
-        res.setHeader('Content-Type', 'application/json');
-        res.end(JSON.stringify(result));
-    } else {
-        if (!res.aborted) {
-            res.cork(() => {
-                res.writeStatus('200 OK').writeHeader('Content-Type', 'application/json').end(JSON.stringify(result));
-            });
-        } else {
-            logger.debug("response aborted");
-            return;
-        }
-    }
-    const duration = performance.now() - req.startTs;
-    IncreaseTotalRequests();
-    RecordRequestDuration(req.method.toLowerCase(), res.handlerName, 200, duration/1000.0);
-}
-
-const getParticularSession = async function (roomId, filters, all=false) {
-    let sessInfo = await getSessionFromCache(roomId);
-    if (!sessInfo) {
-        return null;
-    }
-    if (!hasFilters(filters)) {
-        return sessInfo;
-    }
-    const result = isValidSession(sessInfo, filters.filter)
-    if (result.matched) {
-        return sessInfo;
-    }
-    return null;
-}
-
-const getAllSessions = async  function (projectKey, filters, counters, onlineOnly= false) {
-    const sessions = [];
-    const connected_sockets = await fetchSockets();
-    if (connected_sockets.length === 0) {
-        return sessions;
-    }
-
-    const rooms = new Map();
-    for (let item of connected_sockets) {
-        // Prefilter checks
-        if (rooms.has(item.handshake.query.roomId)) {
-            continue;
-        }
-        if (item.handshake.query.projectKey !== projectKey || !item.handshake.query.sessionInfo) {
-            continue;
-        }
-        if (onlineOnly && item.handshake.query.identity !== IDENTITIES.session) {
-            continue;
-        }
-
-        // Mark this room as visited
-        rooms.set(item.handshake.query.roomId, true);
-
-        // Add session to the list without filtering
-        if (!hasFilters(filters)) {
-            sessions.push(item.handshake.query.sessionInfo);
-            continue;
-        }
-
-        // Add session to the list if it passes the filter
-        const result = isValidSession(item.handshake.query.sessionInfo, filters.filter)
-        if (result.matched) {
-            sessions.push(item.handshake.query.sessionInfo);
-            // Add filter name/value to counter
-            for (const [filterName, filterValue] of Object.entries(result.filters)) {
-                if (counters[filterName] === undefined) {
-                    counters[filterName] = {};
-                }
-                if (counters[filterName][filterValue] === undefined) {
-                    counters[filterName][filterValue] = 0;
-                }
-                counters[filterName][filterValue] += 1;
-            }
-        }
-    }
-
-    return sessions
-}
-
-// Sort by projectKey
-const socketsListByProject = async function (req, res) {
-    logger.debug("[WS]looking for available sessions");
-    res.handlerName = 'socketsListByProject';
-
-    const _projectKey = extractProjectKeyFromRequest(req);
-    const _sessionId = extractSessionIdFromRequest(req);
-    const filters = await extractPayloadFromRequest(req, res);
-
-    // find a particular session
-    if (_sessionId) {
-        const sessInfo = await getParticularSession(_sessionId, filters);//(`${_projectKey}-${_sessionId}`, filters);
-        return respond(req, res, sessInfo);
-    }
-
-    // find all sessions for a project
-    const counters = {};
-    const sessions = await getAllSessions(_projectKey, filters, counters);
-
-    // send response
-    respond(req, res, sortPaginate(sessions, filters, counters));
-}
-
-// Sort by projectKey
-const socketsLiveByProject = async function (req, res) {
-    logger.debug("[WS]looking for available LIVE sessions");
-    res.handlerName = 'socketsLiveByProject';
-
-    const _projectKey = extractProjectKeyFromRequest(req);
-    const _sessionId = extractSessionIdFromRequest(req);
-    const filters = await extractPayloadFromRequest(req, res);
-
-    // find a particular session
-    if (_sessionId) {
-        let sessInfo = await getParticularSession(_sessionId, filters);//(`${_projectKey}-${_sessionId}`, filters);
-        return respond(req, res, sessInfo);
-    }
-
-    // find all sessions for a project
-    const counters = {};
-    const sessions = await getAllSessions(_projectKey, filters, counters, true);
-
-    // send response
-    respond(req, res, sortPaginate(sessions, filters, counters));
-}
-
-// Sort by roomID (projectKey+sessionId)
-const socketsLiveBySession = async function (req, res) {
-    logger.debug("[WS]looking for LIVE session");
-    res.handlerName = 'socketsLiveBySession';
-
-    const _projectKey = extractProjectKeyFromRequest(req);
-    const _sessionId = extractSessionIdFromRequest(req);
-    const filters = await extractPayloadFromRequest(req, res);
-
-    // find a particular session
-    if (_sessionId) {
-        let sessInfo = await getParticularSession(_sessionId, filters);//(`${_projectKey}-${_sessionId}`, filters, true);
-        return respond(req, res, sessInfo);
-    }
-    return respond(req, res, null);
-}
-
-// Sort by projectKey
-const autocomplete = async function (req, res) {
-    logger.debug("[WS]autocomplete");
-    res.handlerName = 'autocomplete';
-
-    const _projectKey = extractProjectKeyFromRequest(req);
-    const filters = await extractPayloadFromRequest(req);
-    let results = [];
-    if (!hasQuery(filters)) {
-        return respond(req, res, results);
-    }
-
-    let connected_sockets = await fetchSockets();
-    if (connected_sockets.length === 0) {
-        return results;
-    }
-
-    const rooms = new Map();
-    for (let item of connected_sockets) {
-        if (rooms.has(item.handshake.query.roomId)) {
-            continue;
-        }
-        if (item.handshake.query.sessionInfo) {
-            if ((item.handshake.query.projectKey !== _projectKey) || (item.handshake.query.identity !== IDENTITIES.session)) {
-                continue;
-            }
-            // Mark this room as visited
-            rooms.set(item.handshake.query.roomId, true);
-            results.push(...getValidAttributes(item.handshake.query.sessionInfo, filters.query))
-        }
-    }
-
-    respond(req, res, uniqueAutocomplete(results));
-}
-
-module.exports = {
-    respond,
-    socketsListByProject,
-    socketsLiveByProject,
-    socketsLiveBySession,
-    autocomplete
-}

ee/assist/utils/socketHandlers.js

@@ -1,250 +0,0 @@
-const {
-    extractPeerId,
-} = require("./helper");
-const {
-    IDENTITIES,
-    EVENTS_DEFINITION,
-    extractSessionInfo,
-    errorHandler
-} = require("./assistHelper");
-const {
-    startAssist,
-    endAssist,
-    handleEvent
-} = require("./stats");
-const {
-    sendTo,
-    sendFrom,
-    fetchSockets,
-    addSessionToCache,
-    getSessionFromCache,
-    removeSessionFromCache
-} = require('../utils/wsServer');
-const {
-    IncreaseTotalWSConnections,
-    IncreaseOnlineConnections,
-    DecreaseOnlineConnections,
-    IncreaseTotalRooms,
-    IncreaseOnlineRooms,
-    DecreaseOnlineRooms,
-} = require('../utils/metrics');
-const {logger} = require('./logger');
-const deepMerge = require('@fastify/deepmerge')({all: true});
-
-const findSessionSocketId = async (roomId, tabId) => {
-    let pickFirstSession = tabId === undefined;
-    const connected_sockets = await fetchSockets(roomId);
-    for (let socket of connected_sockets) {
-        if (socket.handshake.query.identity === IDENTITIES.session) {
-            if (pickFirstSession) {
-                return socket.id;
-            } else if (socket.handshake.query.tabId === tabId) {
-                return socket.id;
-            }
-        }
-    }
-    return null;
-};
-
-async function getRoomData(roomID) {
-    let tabsCount = 0, agentsCount = 0, tabIDs = [], agentIDs = [];
-    const connected_sockets = await fetchSockets(roomID);
-    if (connected_sockets.length > 0) {
-        for (let socket of connected_sockets) {
-            if (socket.handshake.query.identity === IDENTITIES.session) {
-                tabsCount++;
-                tabIDs.push(socket.handshake.query.tabId);
-            } else {
-                agentsCount++;
-                agentIDs.push(socket.id);
-            }
-        }
-    } else {
-        tabsCount = -1;
-        agentsCount = -1;
-    }
-    return {tabsCount, agentsCount, tabIDs, agentIDs};
-}
-
-function processNewSocket(socket) {
-    socket._connectedAt = new Date();
-    let {projectKey: connProjectKey, sessionId: connSessionId, tabId: connTabId} = extractPeerId(socket.handshake.query.peerId);
-    socket.handshake.query.roomId = `${connProjectKey}-${connSessionId}`;
-    socket.handshake.query.projectKey = connProjectKey;
-    socket.handshake.query.sessId = connSessionId;
-    socket.handshake.query.tabId = connTabId;
-    logger.debug(`connProjectKey:${connProjectKey}, connSessionId:${connSessionId}, connTabId:${connTabId}, roomId:${socket.handshake.query.roomId}`);
-}
-
-async function onConnect(socket) {
-    logger.debug(`WS started:${socket.id}, Query:${JSON.stringify(socket.handshake.query)}`);
-    processNewSocket(socket);
-    IncreaseTotalWSConnections(socket.handshake.query.identity);
-    IncreaseOnlineConnections(socket.handshake.query.identity);
-
-    const {tabsCount, agentsCount, tabIDs, agentIDs} = await getRoomData(socket.handshake.query.roomId);
-
-    if (socket.handshake.query.identity === IDENTITIES.session) {
-        // Check if session with the same tabID already connected, if so, refuse new connexion
-        if (tabsCount > 0) {
-            for (let tab of tabIDs) {
-                if (tab === socket.handshake.query.tabId) {
-                    logger.debug(`session already connected, refusing new connexion, peerId: ${socket.handshake.query.peerId}`);
-                    sendTo(socket.id, EVENTS_DEFINITION.emit.SESSION_ALREADY_CONNECTED);
-                    return socket.disconnect();
-                }
-            }
-        }
-        extractSessionInfo(socket);
-        if (tabsCount < 0) {
-            // New session creates new room
-            IncreaseTotalRooms();
-            IncreaseOnlineRooms();
-        }
-        // Inform all connected agents about reconnected session
-        if (agentsCount > 0) {
-            logger.debug(`notifying new session about agent-existence`);
-            sendTo(socket.id, EVENTS_DEFINITION.emit.AGENTS_CONNECTED, agentIDs);
-            sendFrom(socket, socket.handshake.query.roomId, EVENTS_DEFINITION.emit.SESSION_RECONNECTED, socket.id);
-        }
-    } else if (tabsCount <= 0) {
-        logger.debug(`notifying new agent about no SESSIONS with peerId:${socket.handshake.query.peerId}`);
-        sendTo(socket.id, EVENTS_DEFINITION.emit.NO_SESSIONS);
-    }
-    await socket.join(socket.handshake.query.roomId);
-
-    // Add session to cache
-    if (socket.handshake.query.identity === IDENTITIES.session) {
-        await addSessionToCache(socket.handshake.query.sessId, socket.handshake.query.sessionInfo);
-    }
-
-    logger.debug(`${socket.id} joined room:${socket.handshake.query.roomId}, as:${socket.handshake.query.identity}, connections:${agentsCount + tabsCount + 1}`)
-
-    if (socket.handshake.query.identity === IDENTITIES.agent) {
-        if (socket.handshake.query.agentInfo !== undefined) {
-            socket.handshake.query.agentInfo = JSON.parse(socket.handshake.query.agentInfo);
-            socket.handshake.query.agentID = socket.handshake.query.agentInfo.id;
-            // Stats
-            startAssist(socket, socket.handshake.query.agentID);
-        }
-        sendFrom(socket, socket.handshake.query.roomId, EVENTS_DEFINITION.emit.NEW_AGENT, socket.id, socket.handshake.query.agentInfo);
-    }
-
-    // Set disconnect handler
-    socket.on('disconnect', () => onDisconnect(socket));
-
-    // Handle update event
-    socket.on(EVENTS_DEFINITION.listen.UPDATE_EVENT, (...args) => onUpdateEvent(socket, ...args));
-
-    // Handle webrtc events
-    socket.on(EVENTS_DEFINITION.listen.WEBRTC_AGENT_CALL, (...args) => onWebrtcAgentHandler(socket, ...args));
-
-    // Handle errors
-    socket.on(EVENTS_DEFINITION.listen.ERROR, err => errorHandler(EVENTS_DEFINITION.listen.ERROR, err));
-    socket.on(EVENTS_DEFINITION.listen.CONNECT_ERROR, err => errorHandler(EVENTS_DEFINITION.listen.CONNECT_ERROR, err));
-    socket.on(EVENTS_DEFINITION.listen.CONNECT_FAILED, err => errorHandler(EVENTS_DEFINITION.listen.CONNECT_FAILED, err));
-
-    // Handle all other events
-    socket.onAny((eventName, ...args) => onAny(socket, eventName, ...args));
-}
-
-async function onDisconnect(socket) {
-    DecreaseOnlineConnections(socket.handshake.query.identity);
-    logger.debug(`${socket.id} disconnected from ${socket.handshake.query.roomId}`);
-
-    if (socket.handshake.query.identity === IDENTITIES.agent) {
-        sendFrom(socket, socket.handshake.query.roomId, EVENTS_DEFINITION.emit.AGENT_DISCONNECT, socket.id);
-        // Stats
-        endAssist(socket, socket.handshake.query.agentID);
-    }
-    logger.debug("checking for number of connected agents and sessions");
-    let {tabsCount, agentsCount, tabIDs, agentIDs} = await getRoomData(socket.handshake.query.roomId);
-
-    if (tabsCount <= 0) {
-        await removeSessionFromCache(socket.handshake.query.sessId);
-    }
-
-    if (tabsCount === -1 && agentsCount === -1) {
-        DecreaseOnlineRooms();
-        logger.debug(`room not found: ${socket.handshake.query.roomId}`);
-        return;
-    }
-    if (tabsCount === 0) {
-        logger.debug(`notifying everyone in ${socket.handshake.query.roomId} about no SESSIONS`);
-        sendFrom(socket, socket.handshake.query.roomId, EVENTS_DEFINITION.emit.NO_SESSIONS);
-    }
-    if (agentsCount === 0) {
-        logger.debug(`notifying everyone in ${socket.handshake.query.roomId} about no AGENTS`);
-        sendFrom(socket, socket.handshake.query.roomId, EVENTS_DEFINITION.emit.NO_AGENTS);
-    }
-}
-
-async function onUpdateEvent(socket, ...args) {
-    logger.debug(`${socket.id} sent update event.`);
-    if (socket.handshake.query.identity !== IDENTITIES.session) {
-        logger.debug('Ignoring update event.');
-        return
-    }
-
-    args[0] = updateSessionData(socket, args[0])
-    socket.handshake.query.sessionInfo = deepMerge(socket.handshake.query.sessionInfo, args[0]?.data, {tabId: args[0]?.meta?.tabId});
-
-    // update session cache
-    await addSessionToCache(socket.handshake.query.sessId, socket.handshake.query.sessionInfo);
-
-    // Update sessionInfo for all agents in the room
-    const connected_sockets = await fetchSockets(socket.handshake.query.roomId);
-    for (let item of connected_sockets) {
-        if (item.handshake.query.identity === IDENTITIES.session && item.handshake.query.sessionInfo) {
-            item.handshake.query.sessionInfo = deepMerge(item.handshake.query.sessionInfo, args[0]?.data, {tabId: args[0]?.meta?.tabId});
-        } else if (item.handshake.query.identity === IDENTITIES.agent) {
-            sendFrom(socket, item.id, EVENTS_DEFINITION.emit.UPDATE_EVENT, args[0]);
-        }
-    }
-}
-
-async function onWebrtcAgentHandler(socket, ...args) {
-    if (socket.handshake.query.identity === IDENTITIES.agent) {
-        const agentIdToConnect = args[0]?.data?.toAgentId;
-        logger.debug(`${socket.id} sent webrtc event to agent:${agentIdToConnect}`);
-        if (agentIdToConnect && socket.handshake.sessionData.AGENTS_CONNECTED.includes(agentIdToConnect)) {
-            sendFrom(socket, agentIdToConnect, EVENTS_DEFINITION.listen.WEBRTC_AGENT_CALL, args[0]);
-        }
-    }
-}
-
-async function onAny(socket, eventName, ...args) {
-    if (Object.values(EVENTS_DEFINITION.listen).indexOf(eventName) >= 0) {
-        logger.debug(`received event:${eventName}, should be handled by another listener, stopping onAny.`);
-        return
-    }
-    args[0] = updateSessionData(socket, args[0])
-    if (socket.handshake.query.identity === IDENTITIES.session) {
-        logger.debug(`received event:${eventName}, from:${socket.handshake.query.identity}, sending message to room:${socket.handshake.query.roomId}`);
-        sendFrom(socket, socket.handshake.query.roomId, eventName, args[0]);
-    } else {
-        // Stats
-        handleEvent(eventName, socket, args[0]);
-        logger.debug(`received event:${eventName}, from:${socket.handshake.query.identity}, sending message to session of room:${socket.handshake.query.roomId}`);
-        let socketId = await findSessionSocketId(socket.handshake.query.roomId, args[0]?.meta?.tabId);
-        if (socketId === null) {
-            logger.debug(`session not found for:${socket.handshake.query.roomId}`);
-            sendTo(socket.id, EVENTS_DEFINITION.emit.NO_SESSIONS);
-        } else {
-            logger.debug("message sent");
-            sendTo(socket.id, eventName, socket.id, args[0]);
-        }
-    }
-}
-
-// Back compatibility (add top layer with meta information)
-function updateSessionData(socket, sessionData) {
-    if (sessionData?.meta === undefined && socket.handshake.query.identity === IDENTITIES.session) {
-        sessionData = {meta: {tabId: socket.handshake.query.tabId, version: 1}, data: sessionData};
-    }
-    return sessionData
-}
-
-module.exports = {
-    onConnect,
-}

ee/assist/utils/wsServer.js

@@ -3,54 +3,13 @@ const {getCompressionConfig} = require("./helper");
 const {logger} = require('./logger');
 
 let io;
+const getServer = function () {return io;}
 
 const useRedis = process.env.redis === "true";
-const useStickySessions = process.env.stickySessions === "true";
 let inMemorySocketsCache = [];
 let lastCacheUpdateTime = 0;
 const CACHE_REFRESH_INTERVAL = parseInt(process.env.cacheRefreshInterval) || 5000;
 
-let redisClient;
-if (useRedis) {
-    const {createClient} = require("redis");
-    const REDIS_URL = (process.env.REDIS_URL || "localhost:6379").replace(/((^\w+:|^)\/\/|^)/, 'redis://');
-    redisClient = createClient({url: REDIS_URL});
-    redisClient.on("error", (error) => logger.error(`Redis cache error : ${error}`));
-    void redisClient.connect();
-}
-
-const addSessionToCache =  async function (sessionID, sessionData) {
-    try {
-        await redisClient.set(`active_sessions:${sessionID}`, JSON.stringify(sessionData), 'EX', 3600); // 60 minutes
-        logger.debug(`Session ${sessionID} stored in Redis`);
-    } catch (error) {
-        logger.error(error);
-    }
-}
-
-const getSessionFromCache = async function (sessionID) {
-    try {
-        const sessionData = await redisClient.get(`active_sessions:${sessionID}`);
-        if (sessionData) {
-            logger.debug(`Session ${sessionID} retrieved from Redis`);
-            return JSON.parse(sessionData);
-        }
-        return null;
-    } catch (error) {
-        logger.error(error);
-        return null;
-    }
-}
-
-const removeSessionFromCache = async function (sessionID) {
-    try {
-        await redisClient.del(`active_sessions:${sessionID}`);
-        logger.debug(`Session ${sessionID} removed from Redis`);
-    } catch (error) {
-        logger.error(error);
-    }
-}
-
 const doFetchAllSockets = async function () {
     if (useRedis) {
         const now = Date.now();
@@ -90,77 +49,59 @@ function startCacheRefresher() {
     }, CACHE_REFRESH_INTERVAL / 2);
 }
 
-function sendFrom(from, to, eventName, ...data) {
-    if (useStickySessions) {
-        from.local.to(to).emit(eventName, ...data);
-    } else {
-        from.to(to).emit(eventName, ...data);
+const processSocketsList = function (sockets) {
+    let res = []
+    for (let socket of sockets) {
+        let {handshake} = socket;
+        res.push({handshake});
     }
+    return res
 }
 
-function sendTo(to, eventName, ...data) {
-    sendFrom(io, to, eventName, ...data);
-}
-
-const fetchSockets = async function (roomID, all=false) {
+const fetchSockets = async function (roomID) {
     if (!io) {
         return [];
     }
     if (!roomID) {
         return await doFetchAllSockets();
     }
-    try {
-        if (useStickySessions && !all) {
-            return await io.local.in(roomID).fetchSockets();
-        } else {
-            return await io.in(roomID).fetchSockets();
-        }
-    } catch (error) {
-        logger.error('Error fetching sockets:', error);
-        return [];
-    }
+    return await io.in(roomID).fetchSockets();
 }
 
 const createSocketIOServer = function (server, prefix) {
     if (io) {
         return io;
     }
-
-    // Common options for both initialization methods
-    const options = {
-        maxHttpBufferSize: (parseFloat(process.env.maxHttpBufferSize) || 5) * 1e6,
-        cors: {
-            origin: "*",
-            methods: ["GET", "POST", "PUT"],
-            credentials: true
-        },
-        path: (prefix ? prefix : '') + '/socket',
-        ...getCompressionConfig()
-    };
-
     if (process.env.uws !== "true") {
-        io = _io(server, options);
+        io = _io(server, {
+            maxHttpBufferSize: (parseFloat(process.env.maxHttpBufferSize) || 5) * 1e6,
+            cors: {
+                origin: "*",
+                methods: ["GET", "POST", "PUT"],
+                credentials: true
+            },
+            path: (prefix ? prefix : '') + '/socket',
+            ...getCompressionConfig()
+        });
     } else {
-        io = new _io.Server(options);
+        io = new _io.Server({
+            maxHttpBufferSize: (parseFloat(process.env.maxHttpBufferSize) || 5) * 1e6,
+            cors: {
+                origin: "*",
+                methods: ["GET", "POST", "PUT"],
+                credentials: true
+            },
+            path: (prefix ? prefix : '') + '/socket',
+            ...getCompressionConfig()
+        });
         io.attachApp(server);
     }
-
-    io.engine.on("headers", (headers) => {
-        headers["x-host-id"] = process.env.HOSTNAME || "unknown";
-    });
-
-    if (useRedis) {
-        startCacheRefresher();
-    }
+    startCacheRefresher();
     return io;
 }
 
 module.exports = {
     createSocketIOServer,
-    sendTo,
-    sendFrom,
+    getServer,
     fetchSockets,
-    addSessionToCache,
-    getSessionFromCache,
-    removeSessionFromCache,
 }

ee/backend/pkg/sessions/storage.go

@@ -121,16 +121,7 @@ func (s *storageImpl) Get(sessionID uint64) (*Session, error) {
 
 // For the ender service only
 func (s *storageImpl) GetMany(sessionIDs []uint64) ([]*Session, error) {
-	rows, err := s.db.Query(`
-	SELECT 
-		session_id, 
-		CASE 
-			WHEN duration IS NULL OR duration < 0 THEN 0 
-			ELSE duration 
-		END, 
-		start_ts 
-	FROM sessions 
-	WHERE session_id = ANY($1)`, pq.Array(sessionIDs))
+	rows, err := s.db.Query("SELECT session_id, COALESCE( duration, 0 ), start_ts FROM sessions WHERE session_id = ANY($1)", pq.Array(sessionIDs))
 	if err != nil {
 		return nil, err
 	}

ee/scripts/schema/db/init_dbs/clickhouse/1.22.0/1.22.0.sql

@@ -1,3 +1,16 @@
+SELECT 1
+FROM (SELECT throwIf(platform = 'ios', 'IOS sessions found')
+      FROM experimental.sessions) AS raw
+LIMIT 1;
+
+SELECT 1
+FROM (SELECT throwIf(platform = 'android', 'Android sessions found')
+      FROM experimental.sessions) AS raw
+LIMIT 1;
+
+ALTER TABLE experimental.sessions
+    MODIFY COLUMN platform Enum8('web'=1,'mobile'=2) DEFAULT 'web';
+
 CREATE OR REPLACE FUNCTION openreplay_version AS() -> 'v1.22.0-ee';
 
 SET allow_experimental_json_type = 1;
@@ -151,8 +164,7 @@ CREATE TABLE IF NOT EXISTS product_analytics.events
     _timestamp                  DateTime DEFAULT now()
 ) ENGINE = ReplacingMergeTree(_timestamp)
       ORDER BY (project_id, "$event_name", created_at, session_id)
-      TTL _timestamp + INTERVAL 1 MONTH ,
-          _deleted_at + INTERVAL 1 DAY DELETE WHERE _deleted_at != '1970-01-01 00:00:00';
+      TTL _deleted_at + INTERVAL 1 DAY DELETE WHERE _deleted_at != '1970-01-01 00:00:00';
 
 -- The list of events that should not be ingested,
 -- according to a specific event_name and optional properties

ee/scripts/schema/db/init_dbs/clickhouse/1.23.0/1.23.0.sql

@@ -1,13 +0,0 @@
-CREATE OR REPLACE FUNCTION openreplay_version AS() -> 'v1.23.0-ee';
-
-
--- The full list of event-properties (used to tell which property belongs to which event)
-CREATE TABLE IF NOT EXISTS product_analytics.event_properties
-(
-    project_id    UInt16,
-    event_name    String,
-    property_name String,
-
-    _timestamp    DateTime DEFAULT now()
-) ENGINE = ReplacingMergeTree(_timestamp)
-      ORDER BY (project_id, event_name, property_name);

ee/scripts/schema/db/init_dbs/clickhouse/create/init_schema.sql

@@ -1,4 +1,4 @@
-CREATE OR REPLACE FUNCTION openreplay_version AS() -> 'v1.23.0-ee';
+CREATE OR REPLACE FUNCTION openreplay_version AS() -> 'v1.22.0-ee';
 CREATE DATABASE IF NOT EXISTS experimental;
 
 CREATE TABLE IF NOT EXISTS experimental.autocomplete
@@ -9,8 +9,7 @@ CREATE TABLE IF NOT EXISTS experimental.autocomplete
     _timestamp DateTime DEFAULT now()
 ) ENGINE = ReplacingMergeTree(_timestamp)
       PARTITION BY toYYYYMM(_timestamp)
-      ORDER BY (project_id, type, value)
-      TTL _timestamp + INTERVAL 1 MONTH;
+      ORDER BY (project_id, type, value);
 
 CREATE TABLE IF NOT EXISTS experimental.events
 (
@@ -87,8 +86,7 @@ CREATE TABLE IF NOT EXISTS experimental.events
     _timestamp                     DateTime                             DEFAULT now()
 ) ENGINE = ReplacingMergeTree(_timestamp)
       PARTITION BY toYYYYMM(datetime)
-      ORDER BY (project_id, datetime, event_type, session_id, message_id)
-      TTL datetime + INTERVAL 3 MONTH;
+      ORDER BY (project_id, datetime, event_type, session_id, message_id);
 
 
 
@@ -108,7 +106,7 @@ CREATE TABLE IF NOT EXISTS experimental.sessions
     user_country         Enum8('UN'=-128, 'RW'=-127, 'SO'=-126, 'YE'=-125, 'IQ'=-124, 'SA'=-123, 'IR'=-122, 'CY'=-121, 'TZ'=-120, 'SY'=-119, 'AM'=-118, 'KE'=-117, 'CD'=-116, 'DJ'=-115, 'UG'=-114, 'CF'=-113, 'SC'=-112, 'JO'=-111, 'LB'=-110, 'KW'=-109, 'OM'=-108, 'QA'=-107, 'BH'=-106, 'AE'=-105, 'IL'=-104, 'TR'=-103, 'ET'=-102, 'ER'=-101, 'EG'=-100, 'SD'=-99, 'GR'=-98, 'BI'=-97, 'EE'=-96, 'LV'=-95, 'AZ'=-94, 'LT'=-93, 'SJ'=-92, 'GE'=-91, 'MD'=-90, 'BY'=-89, 'FI'=-88, 'AX'=-87, 'UA'=-86, 'MK'=-85, 'HU'=-84, 'BG'=-83, 'AL'=-82, 'PL'=-81, 'RO'=-80, 'XK'=-79, 'ZW'=-78, 'ZM'=-77, 'KM'=-76, 'MW'=-75, 'LS'=-74, 'BW'=-73, 'MU'=-72, 'SZ'=-71, 'RE'=-70, 'ZA'=-69, 'YT'=-68, 'MZ'=-67, 'MG'=-66, 'AF'=-65, 'PK'=-64, 'BD'=-63, 'TM'=-62, 'TJ'=-61, 'LK'=-60, 'BT'=-59, 'IN'=-58, 'MV'=-57, 'IO'=-56, 'NP'=-55, 'MM'=-54, 'UZ'=-53, 'KZ'=-52, 'KG'=-51, 'TF'=-50, 'HM'=-49, 'CC'=-48, 'PW'=-47, 'VN'=-46, 'TH'=-45, 'ID'=-44, 'LA'=-43, 'TW'=-42, 'PH'=-41, 'MY'=-40, 'CN'=-39, 'HK'=-38, 'BN'=-37, 'MO'=-36, 'KH'=-35, 'KR'=-34, 'JP'=-33, 'KP'=-32, 'SG'=-31, 'CK'=-30, 'TL'=-29, 'RU'=-28, 'MN'=-27, 'AU'=-26, 'CX'=-25, 'MH'=-24, 'FM'=-23, 'PG'=-22, 'SB'=-21, 'TV'=-20, 'NR'=-19, 'VU'=-18, 'NC'=-17, 'NF'=-16, 'NZ'=-15, 'FJ'=-14, 'LY'=-13, 'CM'=-12, 'SN'=-11, 'CG'=-10, 'PT'=-9, 'LR'=-8, 'CI'=-7, 'GH'=-6, 'GQ'=-5, 'NG'=-4, 'BF'=-3, 'TG'=-2, 'GW'=-1, 'MR'=0, 'BJ'=1, 'GA'=2, 'SL'=3, 'ST'=4, 'GI'=5, 'GM'=6, 'GN'=7, 'TD'=8, 'NE'=9, 'ML'=10, 'EH'=11, 'TN'=12, 'ES'=13, 'MA'=14, 'MT'=15, 'DZ'=16, 'FO'=17, 'DK'=18, 'IS'=19, 'GB'=20, 'CH'=21, 'SE'=22, 'NL'=23, 'AT'=24, 'BE'=25, 'DE'=26, 'LU'=27, 'IE'=28, 'MC'=29, 'FR'=30, 'AD'=31, 'LI'=32, 'JE'=33, 'IM'=34, 'GG'=35, 'SK'=36, 'CZ'=37, 'NO'=38, 'VA'=39, 'SM'=40, 'IT'=41, 'SI'=42, 'ME'=43, 'HR'=44, 'BA'=45, 'AO'=46, 'NA'=47, 'SH'=48, 'BV'=49, 'BB'=50, 'CV'=51, 'GY'=52, 'GF'=53, 'SR'=54, 'PM'=55, 'GL'=56, 'PY'=57, 'UY'=58, 'BR'=59, 'FK'=60, 'GS'=61, 'JM'=62, 'DO'=63, 'CU'=64, 'MQ'=65, 'BS'=66, 'BM'=67, 'AI'=68, 'TT'=69, 'KN'=70, 'DM'=71, 'AG'=72, 'LC'=73, 'TC'=74, 'AW'=75, 'VG'=76, 'VC'=77, 'MS'=78, 'MF'=79, 'BL'=80, 'GP'=81, 'GD'=82, 'KY'=83, 'BZ'=84, 'SV'=85, 'GT'=86, 'HN'=87, 'NI'=88, 'CR'=89, 'VE'=90, 'EC'=91, 'CO'=92, 'PA'=93, 'HT'=94, 'AR'=95, 'CL'=96, 'BO'=97, 'PE'=98, 'MX'=99, 'PF'=100, 'PN'=101, 'KI'=102, 'TK'=103, 'TO'=104, 'WF'=105, 'WS'=106, 'NU'=107, 'MP'=108, 'GU'=109, 'PR'=110, 'VI'=111, 'UM'=112, 'AS'=113, 'CA'=114, 'US'=115, 'PS'=116, 'RS'=117, 'AQ'=118, 'SX'=119, 'CW'=120, 'BQ'=121, 'SS'=122,'BU'=123, 'VD'=124, 'YD'=125, 'DD'=126),
     user_city            LowCardinality(String),
     user_state           LowCardinality(String),
-    platform             Enum8('web'=1,'ios'=2,'android'=3) DEFAULT 'web',
+    platform             Enum8('web'=1,'mobile'=2) DEFAULT 'web',
     datetime             DateTime,
     timezone             LowCardinality(Nullable(String)),
     duration             UInt32,
@@ -140,7 +138,6 @@ CREATE TABLE IF NOT EXISTS experimental.sessions
 ) ENGINE = ReplacingMergeTree(_timestamp)
       PARTITION BY toYYYYMMDD(datetime)
       ORDER BY (project_id, datetime, session_id)
-      TTL datetime + INTERVAL 3 MONTH
       SETTINGS index_granularity = 512;
 
 CREATE TABLE IF NOT EXISTS experimental.user_favorite_sessions
@@ -152,8 +149,7 @@ CREATE TABLE IF NOT EXISTS experimental.user_favorite_sessions
     sign       Int8
 ) ENGINE = CollapsingMergeTree(sign)
       PARTITION BY toYYYYMM(_timestamp)
-      ORDER BY (project_id, user_id, session_id)
-      TTL _timestamp + INTERVAL 3 MONTH;
+      ORDER BY (project_id, user_id, session_id);
 
 CREATE TABLE IF NOT EXISTS experimental.user_viewed_sessions
 (
@@ -163,8 +159,7 @@ CREATE TABLE IF NOT EXISTS experimental.user_viewed_sessions
     _timestamp DateTime DEFAULT now()
 ) ENGINE = ReplacingMergeTree(_timestamp)
       PARTITION BY toYYYYMM(_timestamp)
-      ORDER BY (project_id, user_id, session_id)
-      TTL _timestamp + INTERVAL 3 MONTH;
+      ORDER BY (project_id, user_id, session_id);
 
 CREATE TABLE IF NOT EXISTS experimental.user_viewed_errors
 (
@@ -174,8 +169,7 @@ CREATE TABLE IF NOT EXISTS experimental.user_viewed_errors
     _timestamp DateTime DEFAULT now()
 ) ENGINE = ReplacingMergeTree(_timestamp)
       PARTITION BY toYYYYMM(_timestamp)
-      ORDER BY (project_id, user_id, error_id)
-      TTL _timestamp + INTERVAL 3 MONTH;
+      ORDER BY (project_id, user_id, error_id);
 
 CREATE TABLE IF NOT EXISTS experimental.issues
 (
@@ -188,8 +182,7 @@ CREATE TABLE IF NOT EXISTS experimental.issues
     _timestamp     DateTime DEFAULT now()
 ) ENGINE = ReplacingMergeTree(_timestamp)
       PARTITION BY toYYYYMM(_timestamp)
-      ORDER BY (project_id, issue_id, type)
-      TTL _timestamp + INTERVAL 3 MONTH;
+      ORDER BY (project_id, issue_id, type);
 
 
 
@@ -292,8 +285,7 @@ CREATE TABLE IF NOT EXISTS experimental.sessions_feature_flags
     _timestamp      DateTime DEFAULT now()
 ) ENGINE = ReplacingMergeTree(_timestamp)
       PARTITION BY toYYYYMM(datetime)
-      ORDER BY (project_id, datetime, session_id, feature_flag_id, condition_id)
-      TTL datetime + INTERVAL 3 MONTH;
+      ORDER BY (project_id, datetime, session_id, feature_flag_id, condition_id);
 
 CREATE TABLE IF NOT EXISTS experimental.ios_events
 (
@@ -329,8 +321,7 @@ CREATE TABLE IF NOT EXISTS experimental.ios_events
     _timestamp     DateTime                             DEFAULT now()
 ) ENGINE = ReplacingMergeTree(_timestamp)
       PARTITION BY toYYYYMM(datetime)
-      ORDER BY (project_id, datetime, event_type, session_id, message_id)
-      TTL datetime + INTERVAL 3 MONTH;
+      ORDER BY (project_id, datetime, event_type, session_id, message_id);
 
 
 SET allow_experimental_json_type = 1;
@@ -484,8 +475,7 @@ CREATE TABLE IF NOT EXISTS product_analytics.events
     _timestamp                  DateTime DEFAULT now()
 ) ENGINE = ReplacingMergeTree(_timestamp)
       ORDER BY (project_id, "$event_name", created_at, session_id)
-      TTL _timestamp + INTERVAL 1 MONTH ,
-          _deleted_at + INTERVAL 1 DAY DELETE WHERE _deleted_at != '1970-01-01 00:00:00';
+      TTL _deleted_at + INTERVAL 1 DAY DELETE WHERE _deleted_at != '1970-01-01 00:00:00';
 
 -- The list of events that should not be ingested,
 -- according to a specific event_name and optional properties
@@ -654,17 +644,6 @@ CREATE TABLE IF NOT EXISTS product_analytics.all_events
       ORDER BY (project_id, event_name);
 
 
--- The full list of event-properties (used to tell which property belongs to which event)
-CREATE TABLE IF NOT EXISTS product_analytics.event_properties
-(
-    project_id    UInt16,
-    event_name    String,
-    property_name String,
-
-    _timestamp    DateTime DEFAULT now()
-) ENGINE = ReplacingMergeTree(_timestamp)
-      ORDER BY (project_id, event_name, property_name);
-
 -- The full list of properties (events and users)
 CREATE TABLE IF NOT EXISTS product_analytics.all_properties
 (

ee/scripts/schema/db/init_dbs/postgresql/1.23.0/1.23.0.sql

@@ -1,30 +0,0 @@
-\set previous_version 'v1.22.0-ee'
-\set next_version 'v1.23.0-ee'
-SELECT openreplay_version()                       AS current_version,
-       openreplay_version() = :'previous_version' AS valid_previous,
-       openreplay_version() = :'next_version'     AS is_next
-\gset
-
-\if :valid_previous
-\echo valid previous DB version :'previous_version', starting DB upgrade to :'next_version'
-BEGIN;
-SELECT format($fn_def$
-CREATE OR REPLACE FUNCTION openreplay_version()
-    RETURNS text AS
-$$
-SELECT '%1$s'
-$$ LANGUAGE sql IMMUTABLE;
-$fn_def$, :'next_version')
-\gexec
-
---
-
-
-
-COMMIT;
-
-\elif :is_next
-\echo new version detected :'next_version', nothing to do
-\else
-\warn skipping DB upgrade of :'next_version', expected previous version :'previous_version', found :'current_version'
-\endif

ee/scripts/schema/db/init_dbs/postgresql/init_schema.sql

@@ -1,4 +1,4 @@
-\set or_version 'v1.23.0-ee'
+\set or_version 'v1.22.0-ee'
 SET client_min_messages TO NOTICE;
 \set ON_ERROR_STOP true
 SELECT EXISTS (SELECT 1

ee/scripts/schema/db/rollback_dbs/clickhouse/1.23.0/1.23.0.sql

@@ -1,3 +0,0 @@
-CREATE OR REPLACE FUNCTION openreplay_version AS() -> 'v1.22.0-ee';
-
-DROP TABLE IF EXISTS product_analytics.event_properties;

ee/scripts/schema/db/rollback_dbs/postgresql/1.23.0/1.23.0.sql

@@ -1,27 +0,0 @@
-\set previous_version 'v1.23.0-ee'
-\set next_version 'v1.22.0-ee'
-SELECT openreplay_version()                       AS current_version,
-       openreplay_version() = :'previous_version' AS valid_previous,
-       openreplay_version() = :'next_version'     AS is_next
-\gset
-
-\if :valid_previous
-\echo valid previous DB version :'previous_version', starting DB downgrade to :'next_version'
-BEGIN;
-SELECT format($fn_def$
-CREATE OR REPLACE FUNCTION openreplay_version()
-    RETURNS text AS
-$$
-SELECT '%1$s'
-$$ LANGUAGE sql IMMUTABLE;
-$fn_def$, :'next_version')
-\gexec
-
-
-COMMIT;
-
-\elif :is_next
-\echo new version detected :'next_version', nothing to do
-\else
-\warn skipping DB downgrade of :'next_version', expected previous version :'previous_version', found :'current_version'
-\endif

frontend/app/PrivateRoutes.tsx

@@ -1,5 +1,4 @@
 import withSiteIdUpdater from 'HOCs/withSiteIdUpdater';
-import withSiteIdUpdater from 'HOCs/withSiteIdUpdater';
 import React, { Suspense, lazy } from 'react';
 import { Redirect, Route, Switch } from 'react-router-dom';
 import { observer } from 'mobx-react-lite';
@@ -10,7 +9,7 @@ import { Loader } from 'UI';
 
 import APIClient from './api_client';
 import * as routes from './routes';
-import { debounce } from '@/utils';
+import { debounceCall } from '@/utils';
 
 const components: any = {
   SessionPure: lazy(() => import('Components/Session/Session')),
@@ -88,7 +87,6 @@ const ASSIST_PATH = routes.assist();
 const LIVE_SESSION_PATH = routes.liveSession();
 const MULTIVIEW_PATH = routes.multiview();
 const MULTIVIEW_INDEX_PATH = routes.multiviewIndex();
-const ASSIST_STATS_PATH = routes.assistStats();
 
 const USABILITY_TESTING_PATH = routes.usabilityTesting();
 const USABILITY_TESTING_EDIT_PATH = routes.usabilityTestingEdit();
@@ -99,7 +97,6 @@ const SPOT_PATH = routes.spot();
 const SCOPE_SETUP = routes.scopeSetup();
 
 const HIGHLIGHTS_PATH = routes.highlights();
-let debounceSearch: any = () => {};
 
 function PrivateRoutes() {
   const { projectsStore, userStore, integrationsStore, searchStore } = useStore();
@@ -124,14 +121,10 @@ function PrivateRoutes() {
     }
   }, [siteId]);
 
-  React.useEffect(() => {
-    debounceSearch = debounce(() => searchStore.fetchSessions(), 500);
-  }, []);
-
   React.useEffect(() => {
     if (!searchStore.urlParsed) return;
-    debounceSearch();
-  }, [searchStore.instance.filters, searchStore.instance.eventsOrder]);
+    debounceCall(() => searchStore.fetchSessions(true), 250)()
+  }, [searchStore.urlParsed, searchStore.instance.filters, searchStore.instance.eventsOrder]);
 
   return (
     <Suspense fallback={<Loader loading className="flex-1" />}>

frontend/app/components/Assist/ChatWindow/ChatWindow.tsx

@@ -1,7 +1,7 @@
 import React, { useState, useEffect } from 'react';
 import cn from 'classnames';
 import Counter from 'App/components/shared/SessionItem/Counter';
-import Draggable from 'react-draggable';
+import { useDraggable } from '@neodrag/react';
 import type { LocalStream } from 'Player';
 import { PlayerContext } from 'App/components/Session/playerContext';
 import ChatControls from '../ChatControls/ChatControls';
@@ -25,6 +25,8 @@ function ChatWindow({
   isPrestart,
 }: Props) {
   const { t } = useTranslation();
+  const dragRef = React.useRef<HTMLDivElement>(null);
+  useDraggable(dragRef, { bounds: 'body', defaultPosition: { x: 50, y: 200 } })
   const { player } = React.useContext(PlayerContext);
 
   const { toggleVideoLocalStream } = player.assistManager;
@@ -39,11 +41,7 @@ function ChatWindow({
   }, [localVideoEnabled]);
 
   return (
-    <Draggable
-      handle=".handle"
-      bounds="body"
-      defaultPosition={{ x: 50, y: 200 }}
-    >
+    <div ref={dragRef}>
       <div
         className={cn(stl.wrapper, 'fixed radius bg-white shadow-xl mt-16')}
         style={{ width: '280px' }}
@@ -102,7 +100,7 @@ function ChatWindow({
           isPrestart={isPrestart}
         />
       </div>
-    </Draggable>
+    </div>
   );
 }
 

frontend/app/components/Client/Integrations/ProfilerDoc/ProfilerDoc.tsx

@@ -16,10 +16,10 @@ function ProfilerDoc() {
     ? sites.find((site) => site.id === siteId)?.projectKey
     : sites[0]?.projectKey;
 
-  const usage = `import { tracker } from '@openreplay/tracker';
+  const usage = `import OpenReplay from '@openreplay/tracker';
 import trackerProfiler from '@openreplay/tracker-profiler';
 //...
-tracker.configure({
+const tracker = new OpenReplay({
   projectKey: '${projectKey}'
 });
 tracker.start()
@@ -29,12 +29,10 @@ export const profiler = tracker.use(trackerProfiler());
 const fn = profiler('call_name')(() => {
 //...
 }, thisArg); // thisArg is optional`;
-  const usageCjs = `import { tracker } from '@openreplay/tracker/cjs';
-// alternatively you can use dynamic import without /cjs suffix to prevent issues with window scope
-
+  const usageCjs = `import OpenReplay from '@openreplay/tracker/cjs';
 import trackerProfiler from '@openreplay/tracker-profiler/cjs';
 //...
-tracker.configure({
+const tracker = new OpenReplay({
   projectKey: '${projectKey}'
 });
 //...

frontend/app/components/Client/Integrations/Tracker/AssistDoc/AssistNpm.tsx

@@ -7,19 +7,17 @@ import { useTranslation } from 'react-i18next';
 
 function AssistNpm(props) {
   const { t } = useTranslation();
-  const usage = `import { tracker } from '@openreplay/tracker';
+  const usage = `import OpenReplay from '@openreplay/tracker';
 import trackerAssist from '@openreplay/tracker-assist';
-tracker.configure({
+const tracker = new OpenReplay({
   projectKey: '${props.projectKey}',
 });
 tracker.start()
 
 tracker.use(trackerAssist(options)); // check the list of available options below`;
-  const usageCjs = `import { tracker } from '@openreplay/tracker/cjs';
-// alternatively you can use dynamic import without /cjs suffix to prevent issues with window scope
+  const usageCjs = `import OpenReplay from '@openreplay/tracker/cjs';
 import trackerAssist from '@openreplay/tracker-assist/cjs';
-
-tracker.configure({
+const tracker = new OpenReplay({
   projectKey: '${props.projectKey}'
 });
 const trackerAssist = tracker.use(trackerAssist(options)); // check the list of available options below

frontend/app/components/Client/Integrations/Tracker/GraphQLDoc/GraphQLDoc.tsx

@@ -14,20 +14,19 @@ function GraphQLDoc() {
   const projectKey = siteId
     ? sites.find((site) => site.id === siteId)?.projectKey
     : sites[0]?.projectKey;
-  const usage = `import { tracker } from '@openreplay/tracker';
+  const usage = `import OpenReplay from '@openreplay/tracker';
 import trackerGraphQL from '@openreplay/tracker-graphql';
 //...
-tracker.configure({
+const tracker = new OpenReplay({
   projectKey: '${projectKey}'
 });
 tracker.start()
 //...
 export const recordGraphQL = tracker.use(trackerGraphQL());`;
-  const usageCjs = `import { tracker } from '@openreplay/tracker/cjs';
-// alternatively you can use dynamic import without /cjs suffix to prevent issues with window scope
+  const usageCjs = `import OpenReplay from '@openreplay/tracker/cjs';
 import trackerGraphQL from '@openreplay/tracker-graphql/cjs';
 //...
-tracker.configure({
+const tracker = new OpenReplay({
   projectKey: '${projectKey}'
 });
 //...

frontend/app/components/Client/Integrations/Tracker/MobxDoc/MobxDoc.tsx

@@ -15,21 +15,20 @@ function MobxDoc() {
     ? sites.find((site) => site.id === siteId)?.projectKey
     : sites[0]?.projectKey;
 
-  const mobxUsage = `import { tracker } from '@openreplay/tracker';
+  const mobxUsage = `import OpenReplay from '@openreplay/tracker';
 import trackerMobX from '@openreplay/tracker-mobx';
 //...
-tracker.configure({
+const tracker = new OpenReplay({
   projectKey: '${projectKey}'
 });
 tracker.use(trackerMobX(<options>)); // check list of available options below
 tracker.start();
 `;
 
-  const mobxUsageCjs = `import { tracker } from '@openreplay/tracker/cjs';
-// alternatively you can use dynamic import without /cjs suffix to prevent issues with window scope
+  const mobxUsageCjs = `import OpenReplay from '@openreplay/tracker/cjs';
 import trackerMobX from '@openreplay/tracker-mobx/cjs';
 //...
-tracker.configure({
+const tracker = new OpenReplay({
   projectKey: '${projectKey}'
 });
 tracker.use(trackerMobX(<options>)); // check list of available options below

frontend/app/components/Client/Integrations/Tracker/NgRxDoc/NgRxDoc.tsx

@@ -16,10 +16,10 @@ function NgRxDoc() {
     : sites[0]?.projectKey;
   const usage = `import { StoreModule } from '@ngrx/store';
 import { reducers } from './reducers';
-import { tracker } from '@openreplay/tracker';
+import OpenReplay from '@openreplay/tracker';
 import trackerNgRx from '@openreplay/tracker-ngrx';
 //...
-tracker.configure({
+const tracker = new OpenReplay({
   projectKey: '${projectKey}'
 });
 tracker.start()
@@ -32,11 +32,10 @@ const metaReducers = [tracker.use(trackerNgRx(<options>))]; // check list of ava
 export class AppModule {}`;
   const usageCjs = `import { StoreModule } from '@ngrx/store';
 import { reducers } from './reducers';
-import { tracker } from '@openreplay/tracker/cjs';
-// alternatively you can use dynamic import without /cjs suffix to prevent issues with window scope
+import OpenReplay from '@openreplay/tracker/cjs';
 import trackerNgRx from '@openreplay/tracker-ngrx/cjs';
 //...
-tracker.configure({
+const tracker = new OpenReplay({
   projectKey: '${projectKey}'
 });
 //...

frontend/app/components/Client/Integrations/Tracker/PiniaDoc/PiniaDoc.tsx

@@ -17,10 +17,10 @@ function PiniaDoc() {
     ? sites.find((site) => site.id === siteId)?.projectKey
     : sites[0]?.projectKey;
   const usage = `import Vuex from 'vuex'
-import { tracker } from '@openreplay/tracker';
+import OpenReplay from '@openreplay/tracker';
 import trackerVuex from '@openreplay/tracker-vuex';
 //...
-tracker.configure({
+const tracker = new OpenReplay({
   projectKey: '${projectKey}'
 });
 tracker.start()

frontend/app/components/Client/Integrations/Tracker/ReduxDoc/ReduxDoc.tsx

@@ -16,10 +16,10 @@ function ReduxDoc() {
     : sites[0]?.projectKey;
 
   const usage = `import { applyMiddleware, createStore } from 'redux';
-import { tracker } from '@openreplay/tracker';
+import OpenReplay from '@openreplay/tracker';
 import trackerRedux from '@openreplay/tracker-redux';
 //...
-tracker.configure({
+const tracker = new OpenReplay({
   projectKey: '${projectKey}'
 });
 tracker.start()
@@ -29,11 +29,10 @@ const store = createStore(
   applyMiddleware(tracker.use(trackerRedux(<options>))) // check list of available options below
 );`;
   const usageCjs = `import { applyMiddleware, createStore } from 'redux';
-import { tracker } from '@openreplay/tracker/cjs';
-// alternatively you can use dynamic import without /cjs suffix to prevent issues with window scope
+import OpenReplay from '@openreplay/tracker/cjs';
 import trackerRedux from '@openreplay/tracker-redux/cjs';
 //...
-tracker.configure({
+const tracker = new OpenReplay({
   projectKey: '${projectKey}'
 });
 //...

frontend/app/components/Client/Integrations/Tracker/VueDoc/VueDoc.tsx

@@ -16,10 +16,10 @@ function VueDoc() {
     : sites[0]?.projectKey;
 
   const usage = `import Vuex from 'vuex'
-import { tracker } from '@openreplay/tracker';
+import OpenReplay from '@openreplay/tracker';
 import trackerVuex from '@openreplay/tracker-vuex';
 //...
-tracker.configure({
+const tracker = new OpenReplay({
   projectKey: '${projectKey}'
 });
 tracker.start()
@@ -29,11 +29,10 @@ const store = new Vuex.Store({
   plugins: [tracker.use(trackerVuex(<options>))] // check list of available options below
 });`;
   const usageCjs = `import Vuex from 'vuex'
-import { tracker } from '@openreplay/tracker/cjs';
-// alternatively you can use dynamic import without /cjs suffix to prevent issues with window scope
+import OpenReplay from '@openreplay/tracker/cjs';
 import trackerVuex from '@openreplay/tracker-vuex/cjs';
 //...
-tracker.configure({
+const tracker = new OpenReplay({
   projectKey: '${projectKey}'
 });
 //...

frontend/app/components/Client/Integrations/Tracker/ZustandDoc/ZustandDoc.tsx

@@ -16,10 +16,11 @@ function ZustandDoc(props) {
     : sites[0]?.projectKey;
 
   const usage = `import create from "zustand";
-import { tracker } from '@openreplay/tracker';
+import Tracker from '@openreplay/tracker';
 import trackerZustand, { StateLogger } from '@openreplay/tracker-zustand';
 
-tracker.configure({
+
+const tracker = new Tracker({
   projectKey: ${projectKey},
 });
 
@@ -42,12 +43,11 @@ const useBearStore = create(
 )
 `;
   const usageCjs = `import create from "zustand";
-import { tracker } from '@openreplay/tracker/cjs';
-// alternatively you can use dynamic import without /cjs suffix to prevent issues with window scope
+import Tracker from '@openreplay/tracker/cjs';
 import trackerZustand, { StateLogger } from '@openreplay/tracker-zustand/cjs';
 
 
-tracker.configure({
+const tracker = new Tracker({
   projectKey: ${projectKey},
 });
 

frontend/app/components/Client/Modules/ModuleCard.tsx

@@ -24,7 +24,7 @@ function ModuleCard(props: Props) {
           <Switch
             size="small"
             checked={!module.isEnabled}
-            title={module.isEnabled ? 'Enabled' : 'Disabled'}
+            title={!module.isEnabled ? 'Enabled' : 'Disabled'}
             onChange={() => props.onToggle(module)}
           />
         </div>

frontend/app/components/Client/Modules/Modules.tsx

@@ -40,11 +40,12 @@ function Modules() {
   };
 
   useEffect(() => {
-    list(t).forEach((module) => {
+    const moduleList = list(t)
+    moduleList.forEach((module) => {
       module.isEnabled = modules.includes(module.key);
     });
     setModulesState(
-      list(t).filter(
+      moduleList.filter(
         (module) => !module.hidden && (!module.enterprise || isEnterprise),
       ),
     );

frontend/app/components/Client/SessionsListingSettings.tsx

@@ -6,6 +6,7 @@ import DefaultPlaying from 'Shared/SessionSettings/components/DefaultPlaying';
 import DefaultTimezone from 'Shared/SessionSettings/components/DefaultTimezone';
 import ListingVisibility from 'Shared/SessionSettings/components/ListingVisibility';
 import MouseTrailSettings from 'Shared/SessionSettings/components/MouseTrailSettings';
+import VirtualModeSettings from '../shared/SessionSettings/components/VirtualMode';
 import DebugLog from './DebugLog';
 import { useTranslation } from 'react-i18next';
 
@@ -35,6 +36,7 @@ function SessionsListingSettings() {
         <div className="flex flex-col gap-2">
           <MouseTrailSettings />
           <DebugLog />
+          <VirtualModeSettings />
         </div>
       </div>
     </div>

frontend/app/components/Dashboard/Widgets/CustomMetricsWidgets/SessionsBy.tsx

@@ -6,6 +6,7 @@ import CardSessionsByList from 'Components/Dashboard/Widgets/CardSessionsByList'
 import { useModal } from 'Components/ModalContext';
 import Widget from '@/mstore/types/widget';
 import { useTranslation } from 'react-i18next';
+import { FilterKey } from 'Types/filter/filterType';
 
 interface Props {
   metric?: any;
@@ -35,20 +36,20 @@ function SessionsBy(props: Props) {
       ...filtersMap[metric.metricOf],
       value: [data.name],
       type: filtersMap[metric.metricOf].key,
-      filters: filtersMap[metric.metricOf].filters?.map((f: any) => {
-        const {
-          key,
-          operatorOptions,
-          category,
-          icon,
-          label,
-          options,
-          ...cleaned
-        } = f;
-        return { ...cleaned, type: f.key, value: [] };
-      }),
+      filters: [],
     };
 
+    if (metric.metricOf === FilterKey.FETCH) {
+      baseFilter.filters = [
+        {
+          key: FilterKey.FETCH_URL,
+          operator: 'is',
+          value: [data.name],
+          type: FilterKey.FETCH_URL,
+        }
+      ];
+    }
+
     const {
       key,
       operatorOptions,

frontend/app/components/Dashboard/components/Alerts/AlertForm/BottomButtons.tsx

@@ -23,6 +23,7 @@ function BottomButtons({
         <Button
           loading={loading}
           type="primary"
+          htmlType="submit"
           disabled={loading || !instance.validate()}
           id="submit-button"
         >

frontend/app/components/Dashboard/components/ClickMapRagePicker/ClickMapRagePicker.tsx

@@ -43,7 +43,7 @@ function ClickMapRagePicker() {
       <Checkbox onChange={onToggle} label={t('Include rage clicks')} />
 
       <Button size="small" onClick={refreshHeatmapSession}>
-        {t('Get new session')}
+        {t('Get new image')}
       </Button>
     </div>
   );

frontend/app/components/Dashboard/components/DashboardView/DashboardView.tsx

@@ -64,6 +64,7 @@ function DashboardView(props: Props) {
   };
 
   useEffect(() => {
+    dashboardStore.resetPeriod();
     if (queryParams.has('modal')) {
       onAddWidgets();
       trimQuery();

frontend/app/components/Dashboard/components/MetricsList/ListView.tsx

@@ -117,8 +117,6 @@ const ListView: React.FC<Props> = ({
     if (disableSelection) {
       const path = withSiteId(`/metrics/${metric.metricId}`, siteId);
       history.push(path);
-    } else {
-      toggleSelection?.(metric.metricId);
     }
   };
 

frontend/app/components/Dashboard/components/MetricsList/MetricsList.tsx

@@ -68,7 +68,7 @@ function MetricsList({
   }, [metricStore]);
 
 
-  const isFiltered = metricStore.filter.query !== '' || metricStore.filter.type !== 'all';
+  const isFiltered = metricStore.filter.query !== '' || metricStore.filter.type !== '';
 
   const searchImageDimensions = { width: 60, height: 'auto' };
   const defaultImageDimensions = { width: 600, height: 'auto' };

frontend/app/components/Dashboard/components/WidgetChart/WidgetChart.tsx

@@ -181,9 +181,10 @@ function WidgetChart(props: Props) {
     }
     prevMetricRef.current = _metric;
     const timestmaps = drillDownPeriod.toTimestamps();
+    const density = props.isPreview ? metric.density : dashboardStore.selectedDensity
     const payload = isSaved
-      ? { ...metricParams }
-      : { ...params, ...timestmaps, ..._metric.toJson() };
+      ? { ...metricParams, density }
+      : { ...params, ...timestmaps, ..._metric.toJson(), density };
     debounceRequest(
       _metric,
       payload,

frontend/app/components/Dashboard/components/WidgetDateRange/RangeGranularity.tsx

@@ -55,7 +55,7 @@ function RangeGranularity({
 }
 
 const PAST_24_HR_MS = 24 * 60 * 60 * 1000;
-function calculateGranularities(periodDurationMs: number) {
+export function calculateGranularities(periodDurationMs: number) {
   const granularities = [
     { label: 'Hourly', durationMs: 60 * 60 * 1000 },
     { label: 'Daily', durationMs: 24 * 60 * 60 * 1000 },

frontend/app/components/Dashboard/components/WidgetSessions/WidgetSessions.tsx

@@ -1,376 +1,395 @@
-import React, { useEffect, useState } from 'react';
-import { NoContent, Loader, Pagination } from 'UI';
-import { Button, Tag, Tooltip, Dropdown, message } from 'antd';
-import { UndoOutlined, DownOutlined } from '@ant-design/icons';
+import React, {useEffect, useState} from 'react';
+import {NoContent, Loader, Pagination} from 'UI';
+import {Button, Tag, Tooltip, Dropdown, message} from 'antd';
+import {UndoOutlined, DownOutlined} from '@ant-design/icons';
 import cn from 'classnames';
-import { useStore } from 'App/mstore';
+import {useStore} from 'App/mstore';
 import SessionItem from 'Shared/SessionItem';
-import { observer } from 'mobx-react-lite';
-import { DateTime } from 'luxon';
-import { debounce, numberWithCommas } from 'App/utils';
+import {observer} from 'mobx-react-lite';
+import {DateTime} from 'luxon';
+import {debounce, numberWithCommas} from 'App/utils';
 import useIsMounted from 'App/hooks/useIsMounted';
-import AnimatedSVG, { ICONS } from 'Shared/AnimatedSVG/AnimatedSVG';
-import { HEATMAP, USER_PATH, FUNNEL } from 'App/constants/card';
-import { useTranslation } from 'react-i18next';
+import AnimatedSVG, {ICONS} from 'Shared/AnimatedSVG/AnimatedSVG';
+import {HEATMAP, USER_PATH, FUNNEL} from 'App/constants/card';
+import {useTranslation} from 'react-i18next';
 
 interface Props {
-  className?: string;
+    className?: string;
 }
 
 function WidgetSessions(props: Props) {
-  const { t } = useTranslation();
-  const listRef = React.useRef<HTMLDivElement>(null);
-  const { className = '' } = props;
-  const [activeSeries, setActiveSeries] = useState('all');
-  const [data, setData] = useState<any>([]);
-  const isMounted = useIsMounted();
-  const [loading, setLoading] = useState(false);
-  // all filtering done through series now
-  const filteredSessions = getListSessionsBySeries(data, 'all');
-  const { dashboardStore, metricStore, sessionStore, customFieldStore } =
-    useStore();
-  const focusedSeries = metricStore.focusedSeriesName;
-  const filter = dashboardStore.drillDownFilter;
-  const widget = metricStore.instance;
-  const startTime = DateTime.fromMillis(filter.startTimestamp).toFormat(
-    'LLL dd, yyyy HH:mm',
-  );
-  const endTime = DateTime.fromMillis(filter.endTimestamp).toFormat(
-    'LLL dd, yyyy HH:mm',
-  );
-  const [seriesOptions, setSeriesOptions] = useState([
-    { label: t('All'), value: 'all' },
-  ]);
-  const hasFilters =
-    filter.filters.length > 0 ||
-    filter.startTimestamp !== dashboardStore.drillDownPeriod.start ||
-    filter.endTimestamp !== dashboardStore.drillDownPeriod.end;
-  const filterText = filter.filters.length > 0 ? filter.filters[0].value : '';
-  const metaList = customFieldStore.list.map((i: any) => i.key);
+    const {t} = useTranslation();
+    const listRef = React.useRef<HTMLDivElement>(null);
+    const {className = ''} = props;
+    const [activeSeries, setActiveSeries] = useState('all');
+    const [data, setData] = useState<any>([]);
+    const isMounted = useIsMounted();
+    const [loading, setLoading] = useState(false);
+    // all filtering done through series now
+    const filteredSessions = getListSessionsBySeries(data, 'all');
+    const {dashboardStore, metricStore, sessionStore, customFieldStore} =
+        useStore();
+    const focusedSeries = metricStore.focusedSeriesName;
+    const filter = dashboardStore.drillDownFilter;
+    const widget = metricStore.instance;
+    const startTime = DateTime.fromMillis(filter.startTimestamp).toFormat(
+        'LLL dd, yyyy HH:mm',
+    );
+    const endTime = DateTime.fromMillis(filter.endTimestamp).toFormat(
+        'LLL dd, yyyy HH:mm',
+    );
+    const [seriesOptions, setSeriesOptions] = useState([
+        {label: t('All'), value: 'all'},
+    ]);
+    const hasFilters =
+        filter.filters.length > 0 ||
+        filter.startTimestamp !== dashboardStore.drillDownPeriod.start ||
+        filter.endTimestamp !== dashboardStore.drillDownPeriod.end;
+    const filterText = filter.filters.length > 0 ? filter.filters[0].value : '';
+    const metaList = customFieldStore.list.map((i: any) => i.key);
 
-  const seriesDropdownItems = seriesOptions.map((option) => ({
-    key: option.value,
-    label: (
-      <div onClick={() => setActiveSeries(option.value)}>{option.label}</div>
-    ),
-  }));
-
-  useEffect(() => {
-    if (!widget.series) return;
-    const seriesOptions = widget.series.map((item: any) => ({
-      label: item.name,
-      value: item.seriesId ?? item.name,
+    const seriesDropdownItems = seriesOptions.map((option) => ({
+        key: option.value,
+        label: (
+            <div onClick={() => setActiveSeries(option.value)}>{option.label}</div>
+        ),
     }));
-    setSeriesOptions([{ label: t('All'), value: 'all' }, ...seriesOptions]);
-  }, [widget.series.length]);
 
-  const fetchSessions = (metricId: any, filter: any) => {
-    if (!isMounted()) return;
-    setLoading(true);
-    delete filter.eventsOrderSupport;
-    if (widget.metricType === FUNNEL) {
-      if (filter.series[0].filter.filters.length === 0) {
-        setLoading(false);
-        return setData([]);
-      }
-    }
+    useEffect(() => {
+        if (!widget.series) return;
+        const seriesOptions = widget.series.map((item: any) => ({
+            label: item.name,
+            value: item.seriesId ?? item.name,
+        }));
+        setSeriesOptions([{label: t('All'), value: 'all'}, ...seriesOptions]);
+    }, [widget.series.length]);
 
-    widget
-      .fetchSessions(metricId, filter)
-      .then((res: any) => {
-        setData(res);
-        if (metricStore.drillDown) {
-          setTimeout(() => {
-            message.info(t('Sessions Refreshed!'));
-            listRef.current?.scrollIntoView({ behavior: 'smooth' });
-            metricStore.setDrillDown(false);
-          }, 0);
+    const fetchSessions = (metricId: any, filter: any) => {
+        if (!isMounted()) return;
+
+        if (widget.metricType === FUNNEL) {
+            if (filter.series[0].filter.filters.length === 0) {
+                setLoading(false);
+                return setData([]);
+            }
         }
-      })
-      .finally(() => {
-        setLoading(false);
-      });
-  };
-  const fetchClickmapSessions = (customFilters: Record<string, any>) => {
-    sessionStore.getSessions(customFilters).then((data) => {
-      setData([{ ...data, seriesId: 1, seriesName: 'Clicks' }]);
-    });
-  };
-  const debounceRequest: any = React.useCallback(
-    debounce(fetchSessions, 1000),
-    [],
-  );
-  const debounceClickMapSearch = React.useCallback(
-    debounce(fetchClickmapSessions, 1000),
-    [],
-  );
 
-  const depsString = JSON.stringify(widget.series);
 
-  const loadData = () => {
-    if (widget.metricType === HEATMAP && metricStore.clickMapSearch) {
-      const clickFilter = {
-        value: [metricStore.clickMapSearch],
-        type: 'CLICK',
-        operator: 'onSelector',
-        isEvent: true,
-        // @ts-ignore
-        filters: [],
-      };
-      const timeRange = {
-        rangeValue: dashboardStore.drillDownPeriod.rangeValue,
-        startDate: dashboardStore.drillDownPeriod.start,
-        endDate: dashboardStore.drillDownPeriod.end,
-      };
-      const customFilter = {
-        ...filter,
-        ...timeRange,
-        filters: [...sessionStore.userFilter.filters, clickFilter],
-      };
-      debounceClickMapSearch(customFilter);
-    } else {
-      const hasStartPoint =
-        !!widget.startPoint && widget.metricType === USER_PATH;
-      const onlyFocused = focusedSeries
-        ? widget.series.filter((s) => s.name === focusedSeries)
-        : widget.series;
-      const activeSeries = metricStore.disabledSeries.length
-        ? onlyFocused.filter(
-            (s) => !metricStore.disabledSeries.includes(s.name),
-          )
-        : onlyFocused;
-      const seriesJson = activeSeries.map((s) => s.toJson());
-      if (hasStartPoint) {
-        seriesJson[0].filter.filters.push(widget.startPoint.toJson());
-      }
-      if (widget.metricType === USER_PATH) {
-        if (
-          seriesJson[0].filter.filters[0].value[0] === '' &&
-          widget.data.nodes
-        ) {
-          seriesJson[0].filter.filters[0].value = widget.data.nodes[0].name;
-        } else if (
-          seriesJson[0].filter.filters[0].value[0] === '' &&
-          !widget.data.nodes?.length
-        ) {
-          // no point requesting if we don't have starting point picked by api
-          return;
+        setLoading(true);
+        const filterCopy = {...filter};
+        delete filterCopy.eventsOrderSupport;
+
+        try {
+            // Handle filters properly with null checks
+            if (filterCopy.filters && filterCopy.filters.length > 0) {
+                // Ensure the nested path exists before pushing
+                if (filterCopy.series?.[0]?.filter) {
+                    if (!filterCopy.series[0].filter.filters) {
+                        filterCopy.series[0].filter.filters = [];
+                    }
+                    filterCopy.series[0].filter.filters.push(...filterCopy.filters);
+                }
+                filterCopy.filters = [];
+            }
+        } catch (e) {
+            // do nothing
         }
-      }
-      debounceRequest(widget.metricId, {
-        ...filter,
-        series: seriesJson,
-        page: metricStore.sessionsPage,
-        limit: metricStore.sessionsPageSize,
-      });
-    }
-  };
-  useEffect(() => {
-    metricStore.updateKey('sessionsPage', 1);
-    loadData();
-  }, [
-    filter.startTimestamp,
-    filter.endTimestamp,
-    filter.filters,
-    depsString,
-    metricStore.clickMapSearch,
-    focusedSeries,
-    widget.startPoint,
-    widget.data.nodes,
-    metricStore.disabledSeries.length,
-  ]);
-  useEffect(loadData, [metricStore.sessionsPage]);
-  useEffect(() => {
-    if (activeSeries === 'all') {
-      metricStore.setFocusedSeriesName(null);
-    } else {
-      metricStore.setFocusedSeriesName(
-        seriesOptions.find((option) => option.value === activeSeries)?.label,
-        false,
-      );
-    }
-  }, [activeSeries]);
-  useEffect(() => {
-    if (focusedSeries) {
-      setActiveSeries(
-        seriesOptions.find((option) => option.label === focusedSeries)?.value ||
-          'all',
-      );
-    } else {
-      setActiveSeries('all');
-    }
-  }, [focusedSeries]);
+        widget
+            .fetchSessions(metricId, filterCopy)
+            .then((res: any) => {
+                setData(res);
+                if (metricStore.drillDown) {
+                    setTimeout(() => {
+                        message.info(t('Sessions Refreshed!'));
+                        listRef.current?.scrollIntoView({behavior: 'smooth'});
+                        metricStore.setDrillDown(false);
+                    }, 0);
+                }
+            })
+            .finally(() => {
+                setLoading(false);
+            });
+    };
+    const fetchClickmapSessions = (customFilters: Record<string, any>) => {
+        sessionStore.getSessions(customFilters).then((data) => {
+            setData([{...data, seriesId: 1, seriesName: 'Clicks'}]);
+        });
+    };
+    const debounceRequest: any = React.useCallback(
+        debounce(fetchSessions, 1000),
+        [],
+    );
+    const debounceClickMapSearch = React.useCallback(
+        debounce(fetchClickmapSessions, 1000),
+        [],
+    );
 
-  const clearFilters = () => {
-    metricStore.updateKey('sessionsPage', 1);
-    dashboardStore.resetDrillDownFilter();
-  };
+    const depsString = JSON.stringify(widget.series);
 
-  return (
-    <div
-      className={cn(
-        className,
-        'bg-white p-3 pb-0 rounded-xl shadow-sm border mt-3',
-      )}
-    >
-      <div className="flex items-center justify-between">
-        <div>
-          <div className="flex items-baseline gap-2">
-            <h2 className="text-xl">
-              {metricStore.clickMapSearch ? t('Clicks') : t('Sessions')}
-            </h2>
-            <div className="ml-2 color-gray-medium">
-              {metricStore.clickMapLabel
-                ? `on "${metricStore.clickMapLabel}" `
-                : null}
-              {t('between')}{' '}
-              <span className="font-medium color-gray-darkest">
+    const loadData = () => {
+        if (widget.metricType === HEATMAP && metricStore.clickMapSearch) {
+            const clickFilter = {
+                value: [metricStore.clickMapSearch],
+                type: 'CLICK',
+                operator: 'onSelector',
+                isEvent: true,
+                // @ts-ignore
+                filters: [],
+            };
+            const timeRange = {
+                rangeValue: dashboardStore.drillDownPeriod.rangeValue,
+                startDate: dashboardStore.drillDownPeriod.start,
+                endDate: dashboardStore.drillDownPeriod.end,
+            };
+            const customFilter = {
+                ...filter,
+                ...timeRange,
+                filters: [...sessionStore.userFilter.filters, clickFilter],
+            };
+            debounceClickMapSearch(customFilter);
+        } else {
+            const hasStartPoint =
+                !!widget.startPoint && widget.metricType === USER_PATH;
+            const onlyFocused = focusedSeries
+                ? widget.series.filter((s) => s.name === focusedSeries)
+                : widget.series;
+            const activeSeries = metricStore.disabledSeries.length
+                ? onlyFocused.filter(
+                    (s) => !metricStore.disabledSeries.includes(s.name),
+                )
+                : onlyFocused;
+            const seriesJson = activeSeries.map((s) => s.toJson());
+            if (hasStartPoint) {
+                seriesJson[0].filter.filters.push(widget.startPoint.toJson());
+            }
+            if (widget.metricType === USER_PATH) {
+                if (
+                    seriesJson[0].filter.filters[0].value[0] === '' &&
+                    widget.data.nodes?.length
+                ) {
+                    seriesJson[0].filter.filters[0].value = widget.data.nodes[0].name;
+                } else if (
+                    seriesJson[0].filter.filters[0].value[0] === '' &&
+                    !widget.data.nodes?.length
+                ) {
+                    // no point requesting if we don't have starting point picked by api
+                    return;
+                }
+            }
+            debounceRequest(widget.metricId, {
+                ...filter,
+                series: seriesJson,
+                page: metricStore.sessionsPage,
+                limit: metricStore.sessionsPageSize,
+            });
+        }
+    };
+    useEffect(() => {
+        metricStore.updateKey('sessionsPage', 1);
+        loadData();
+    }, [
+        filter.startTimestamp,
+        filter.endTimestamp,
+        filter.filters,
+        depsString,
+        metricStore.clickMapSearch,
+        focusedSeries,
+        widget.startPoint,
+        widget.data.nodes,
+        metricStore.disabledSeries.length,
+    ]);
+    useEffect(loadData, [metricStore.sessionsPage]);
+    useEffect(() => {
+        if (activeSeries === 'all') {
+            metricStore.setFocusedSeriesName(null);
+        } else {
+            metricStore.setFocusedSeriesName(
+                seriesOptions.find((option) => option.value === activeSeries)?.label,
+                false,
+            );
+        }
+    }, [activeSeries]);
+    useEffect(() => {
+        if (focusedSeries) {
+            setActiveSeries(
+                seriesOptions.find((option) => option.label === focusedSeries)?.value ||
+                'all',
+            );
+        } else {
+            setActiveSeries('all');
+        }
+    }, [focusedSeries]);
+
+    const clearFilters = () => {
+        metricStore.updateKey('sessionsPage', 1);
+        dashboardStore.resetDrillDownFilter();
+    };
+
+    return (
+        <div
+            className={cn(
+                className,
+                'bg-white p-3 pb-0 rounded-xl shadow-sm border mt-3',
+            )}
+        >
+            <div className="flex items-center justify-between">
+                <div>
+                    <div className="flex items-baseline gap-2">
+                        <h2 className="text-xl">
+                            {metricStore.clickMapSearch ? t('Clicks') : t('Sessions')}
+                        </h2>
+                        <div className="ml-2 color-gray-medium">
+                            {metricStore.clickMapLabel
+                                ? `on "${metricStore.clickMapLabel}" `
+                                : null}
+                            {t('between')}{' '}
+                            <span className="font-medium color-gray-darkest">
                 {startTime}
               </span>{' '}
-              {t('and')}{' '}
-              <span className="font-medium color-gray-darkest">
+                            {t('and')}{' '}
+                            <span className="font-medium color-gray-darkest">
                 {endTime}
               </span>{' '}
-            </div>
-            {hasFilters && (
-              <Tooltip title={t('Clear Drilldown')} placement="top">
-                <Button type="text" size="small" onClick={clearFilters}>
-                  <UndoOutlined />
-                </Button>
-              </Tooltip>
-            )}
-          </div>
+                        </div>
+                        {hasFilters && (
+                            <Tooltip title={t('Clear Drilldown')} placement="top">
+                                <Button type="text" size="small" onClick={clearFilters}>
+                                    <UndoOutlined/>
+                                </Button>
+                            </Tooltip>
+                        )}
+                    </div>
 
-          {hasFilters && widget.metricType === 'table' && (
-            <div className="py-2">
-              <Tag
-                closable
-                onClose={clearFilters}
-                className="truncate max-w-44 rounded-lg"
-              >
-                {filterText}
-              </Tag>
-            </div>
-          )}
-        </div>
+                    {hasFilters && widget.metricType === 'table' && (
+                        <div className="py-2">
+                            <Tag
+                                closable
+                                onClose={clearFilters}
+                                className="truncate max-w-44 rounded-lg"
+                            >
+                                {filterText}
+                            </Tag>
+                        </div>
+                    )}
+                </div>
 
-        <div className="flex items-center gap-4">
-          {widget.metricType !== 'table' && widget.metricType !== HEATMAP && (
-            <div className="flex items-center ml-6">
+                <div className="flex items-center gap-4">
+                    {widget.metricType !== 'table' && widget.metricType !== HEATMAP && (
+                        <div className="flex items-center ml-6">
               <span className="mr-2 color-gray-medium">
                 {t('Filter by Series')}
               </span>
-              <Dropdown
-                menu={{
-                  items: seriesDropdownItems,
-                  selectable: true,
-                  selectedKeys: [activeSeries],
-                }}
-                trigger={['click']}
-              >
-                <Button type="text" size="small">
-                  {seriesOptions.find((option) => option.value === activeSeries)
-                    ?.label || t('Select Series')}
-                  <DownOutlined />
-                </Button>
-              </Dropdown>
-            </div>
-          )}
-        </div>
-      </div>
-
-      <div className="mt-3">
-        <Loader loading={loading}>
-          <NoContent
-            title={
-              <div className="flex items-center justify-center flex-col">
-                <AnimatedSVG name={ICONS.NO_SESSIONS} size={60} />
-                <div className="mt-4" />
-                <div className="text-center">
-                  {t('No relevant sessions found for the selected time period')}
+                            <Dropdown
+                                menu={{
+                                    items: seriesDropdownItems,
+                                    selectable: true,
+                                    selectedKeys: [activeSeries],
+                                }}
+                                trigger={['click']}
+                            >
+                                <Button type="text" size="small">
+                                    {seriesOptions.find((option) => option.value === activeSeries)
+                                        ?.label || t('Select Series')}
+                                    <DownOutlined/>
+                                </Button>
+                            </Dropdown>
+                        </div>
+                    )}
                 </div>
-              </div>
-            }
-            show={filteredSessions.sessions.length === 0}
-          >
-            {filteredSessions.sessions.map((session: any) => (
-              <React.Fragment key={session.sessionId}>
-                <SessionItem
-                  disableUser
-                  session={session}
-                  metaList={metaList}
-                />
-                <div className="border-b" />
-              </React.Fragment>
-            ))}
+            </div>
 
-            <div
-              className="flex items-center justify-between p-5"
-              ref={listRef}
-            >
-              <div>
-                {t('Showing')}{' '}
-                <span className="font-medium">
+            <div className="mt-3">
+                <Loader loading={loading}>
+                    <NoContent
+                        title={
+                            <div className="flex items-center justify-center flex-col">
+                                <AnimatedSVG name={ICONS.NO_SESSIONS} size={60}/>
+                                <div className="mt-4"/>
+                                <div className="text-center">
+                                    {t('No relevant sessions found for the selected time period')}
+                                </div>
+                            </div>
+                        }
+                        show={filteredSessions.sessions.length === 0}
+                    >
+                        {filteredSessions.sessions.map((session: any) => (
+                            <React.Fragment key={session.sessionId}>
+                                <SessionItem
+                                    disableUser
+                                    session={session}
+                                    metaList={metaList}
+                                />
+                                <div className="border-b"/>
+                            </React.Fragment>
+                        ))}
+
+                        <div
+                            className="flex items-center justify-between p-5"
+                            ref={listRef}
+                        >
+                            <div>
+                                {t('Showing')}{' '}
+                                <span className="font-medium">
                   {(metricStore.sessionsPage - 1) *
-                    metricStore.sessionsPageSize +
-                    1}
+                      metricStore.sessionsPageSize +
+                      1}
                 </span>{' '}
-                {t('to')}{' '}
-                <span className="font-medium">
+                                {t('to')}{' '}
+                                <span className="font-medium">
                   {(metricStore.sessionsPage - 1) *
-                    metricStore.sessionsPageSize +
-                    filteredSessions.sessions.length}
+                      metricStore.sessionsPageSize +
+                      filteredSessions.sessions.length}
                 </span>{' '}
-                {t('of')}{' '}
-                <span className="font-medium">
+                                {t('of')}{' '}
+                                <span className="font-medium">
                   {numberWithCommas(filteredSessions.total)}
                 </span>{' '}
-                {t('sessions.')}
-              </div>
-              <Pagination
-                page={metricStore.sessionsPage}
-                total={filteredSessions.total}
-                onPageChange={(page: any) =>
-                  metricStore.updateKey('sessionsPage', page)
-                }
-                limit={metricStore.sessionsPageSize}
-                debounceRequest={500}
-              />
+                                {t('sessions.')}
+                            </div>
+                            <Pagination
+                                page={metricStore.sessionsPage}
+                                total={filteredSessions.total}
+                                onPageChange={(page: any) =>
+                                    metricStore.updateKey('sessionsPage', page)
+                                }
+                                limit={metricStore.sessionsPageSize}
+                                debounceRequest={500}
+                            />
+                        </div>
+                    </NoContent>
+                </Loader>
             </div>
-          </NoContent>
-        </Loader>
-      </div>
-    </div>
-  );
+        </div>
+    );
 }
 
 const getListSessionsBySeries = (data: any, seriesId: any) => {
-  const arr = data.reduce(
-    (arr: any, element: any) => {
-      if (seriesId === 'all') {
-        const sessionIds = arr.sessions.map((i: any) => i.sessionId);
-        const sessions = element.sessions.filter(
-          (i: any) => !sessionIds.includes(i.sessionId),
-        );
-        arr.sessions.push(...sessions);
-      } else if (element.seriesId === seriesId) {
-        const sessionIds = arr.sessions.map((i: any) => i.sessionId);
-        const sessions = element.sessions.filter(
-          (i: any) => !sessionIds.includes(i.sessionId),
-        );
-        const duplicates = element.sessions.length - sessions.length;
-        arr.sessions.push(...sessions);
-        arr.total = element.total - duplicates;
-      }
-      return arr;
-    },
-    { sessions: [] },
-  );
-  arr.total =
-    seriesId === 'all'
-      ? Math.max(...data.map((i: any) => i.total))
-      : data.find((i: any) => i.seriesId === seriesId).total;
-  return arr;
+    const arr = data.reduce(
+        (arr: any, element: any) => {
+            if (seriesId === 'all') {
+                const sessionIds = arr.sessions.map((i: any) => i.sessionId);
+                const sessions = element.sessions.filter(
+                    (i: any) => !sessionIds.includes(i.sessionId),
+                );
+                arr.sessions.push(...sessions);
+            } else if (element.seriesId === seriesId) {
+                const sessionIds = arr.sessions.map((i: any) => i.sessionId);
+                const sessions = element.sessions.filter(
+                    (i: any) => !sessionIds.includes(i.sessionId),
+                );
+                const duplicates = element.sessions.length - sessions.length;
+                arr.sessions.push(...sessions);
+                arr.total = element.total - duplicates;
+            }
+            return arr;
+        },
+        {sessions: []},
+    );
+    arr.total =
+        seriesId === 'all'
+            ? Math.max(...data.map((i: any) => i.total))
+            : data.find((i: any) => i.seriesId === seriesId).total;
+    return arr;
 };
 
 export default observer(WidgetSessions);

frontend/app/components/Dashboard/components/WidgetView/WidgetView.tsx

@@ -92,6 +92,9 @@ function WidgetView({
                 filter: { filters: selectedCard.filters },
               }),
             ];
+          } else if (selectedCard.cardType === TABLE) {
+            cardData.series = [new FilterSeries()];
+            cardData.series[0].filter.eventsOrder = 'and';
           }
           if (selectedCard.cardType === FUNNEL) {
             cardData.series = [new FilterSeries()];

frontend/app/components/Dashboard/components/WidgetWrapper/WidgetWrapperNew.tsx

@@ -83,6 +83,7 @@ function WidgetWrapperNew(props: Props & RouteComponentProps) {
   });
 
   const onChartClick = () => {
+    dashboardStore.setDrillDownPeriod(dashboardStore.period);
     // if (!isWidget || isPredefined) return;
     props.history.push(
       withSiteId(

frontend/app/components/Login/SSOLogin.tsx

@@ -14,7 +14,7 @@ interface SSOLoginProps {
 const SSOLogin = ({ authDetails, enforceSSO = false }: SSOLoginProps) => {
   const { userStore } = useStore();
   const { t } = useTranslation();
-  const { isEnterprise } = userStore;
+  const { isSSOSupported } = userStore;
 
   const getSSOLink = () =>
     window !== window.top
@@ -23,7 +23,7 @@ const SSOLogin = ({ authDetails, enforceSSO = false }: SSOLoginProps) => {
 
   const ssoLink = getSSOLink();
   const ssoButtonText = `${t('Login with SSO')} ${authDetails.ssoProvider ? `(${authDetails.ssoProvider})` : ''
-    }`;
+  }`;
 
   if (enforceSSO) {
     return (
@@ -47,7 +47,7 @@ const SSOLogin = ({ authDetails, enforceSSO = false }: SSOLoginProps) => {
         <Tooltip
           title={
             <div className="text-center">
-              {isEnterprise ? (
+              {isSSOSupported ? (
                 <span>
                   {t('SSO has not been configured.')}
                   <br />

frontend/app/components/Onboarding/components/InstallOpenReplayTab/InstallOpenReplayTab.tsx

@@ -8,6 +8,7 @@ import MobileOnboardingTabs from '../OnboardingTabs/OnboardingMobileTabs';
 import ProjectFormButton from '../ProjectFormButton';
 import withOnboarding, { WithOnboardingProps } from '../withOnboarding';
 import { useTranslation } from 'react-i18next';
+import { CircleHelp } from 'lucide-react'
 
 interface Props extends WithOnboardingProps {
   platforms: Array<{
@@ -45,8 +46,8 @@ function InstallOpenReplayTab(props: Props) {
         </div>
         <a href={"https://docs.openreplay.com/en/sdk/using-or/"} target="_blank">
           <Button size={"small"} type={"text"} className="ml-2 flex items-center gap-2">
-            <Icon name={"question-circle"} />
-            <div className={"text-main"}>{t('See Documentation')}</div>
+            <CircleHelp size={14} />
+            <div>{t('See Documentation')}</div>
           </Button>
         </a>
       </h1>

frontend/app/components/Onboarding/components/OnboardingTabs/Callouts.tsx

@@ -0,0 +1,32 @@
+import React from 'react'
+import DocCard from "App/components/shared/DocCard";
+import { useTranslation } from 'react-i18next';
+import { Mail } from 'lucide-react'
+import { CopyButton } from "UI";
+
+export function CollabCard({ showUserModal }: { showUserModal: () => void }) {
+  const { t } = useTranslation();
+
+  return (
+    <DocCard title={t('Need help from team member?')}>
+      <div className={'text-main cursor-pointer flex items-center gap-2'} onClick={showUserModal}>
+        <Mail size={14} />
+        <span>
+          {t('Invite and Collaborate')}
+        </span>
+      </div>
+    </DocCard>
+  )
+}
+
+export function ProjectKeyCard({ projectKey }: { projectKey: string }) {
+  const { t } = useTranslation();
+  return (
+    <DocCard title={t('Project Key')}>
+      <div className="p-2 rounded bg-white flex justify-between items-center">
+        <div className={'font-mono'}>{projectKey}</div>
+        <CopyButton content={projectKey} className={'capitalize font-medium text-neutral-400'} />
+      </div>
+    </DocCard>
+  )
+}

frontend/app/components/Onboarding/components/OnboardingTabs/InstallDocs/InstallDocs.js

@@ -7,17 +7,16 @@ import stl from './installDocs.module.css';
 import { useTranslation } from 'react-i18next';
 
 const installationCommand = 'npm i @openreplay/tracker';
-const usageCode = `import { tracker } from '@openreplay/tracker';
+const usageCode = `import Tracker from '@openreplay/tracker';
 
-tracker.configure({
+const tracker = new Tracker({
   projectKey: "PROJECT_KEY",
   ingestPoint: "https://${window.location.hostname}/ingest",
 });
 tracker.start()`;
-const usageCodeSST = `import { tracker } from '@openreplay/tracker/cjs';
-// alternatively you can use dynamic import without /cjs suffix to prevent issues with window scope
+const usageCodeSST = `import Tracker from '@openreplay/tracker/cjs';
 
-tracker.configure({
+const tracker = new Tracker({
   projectKey: "PROJECT_KEY",
   ingestPoint: "https://${window.location.hostname}/ingest",
 });

frontend/app/components/Onboarding/components/OnboardingTabs/OnboardingMobileTabs.tsx

@@ -4,6 +4,7 @@ import DocCard from 'Shared/DocCard/DocCard';
 import { useModal } from 'App/components/Modal';
 import UserForm from 'App/components/Client/Users/components/UserForm/UserForm';
 import AndroidInstallDocs from 'Components/Onboarding/components/OnboardingTabs/InstallDocs/AndroidInstallDocs';
+import { CollabCard, ProjectKeyCard } from "./Callouts";
 import MobileInstallDocs from './InstallDocs/MobileInstallDocs';
 import { useTranslation } from 'react-i18next';
 
@@ -39,18 +40,9 @@ function MobileTrackingCodeModal(props: Props) {
             </div>
 
             <div className="col-span-2">
-              <DocCard title={t('Need help from team member?')}>
-                <a className="link" onClick={showUserModal}>
-                  {t('Invite and Collaborate')}
-                </a>
-              </DocCard>
+              <CollabCard showUserModal={showUserModal} />
 
-              <DocCard title={t('Project Key')}>
-                <div className="p-2 rounded bg-white flex justify-between items-center">
-                  {site.projectKey}
-                  <CopyButton content={site.projectKey} />
-                </div>
-              </DocCard>
+              <ProjectKeyCard projectKey={site.projectKey} />
             </div>
           </div>
         );
@@ -62,18 +54,9 @@ function MobileTrackingCodeModal(props: Props) {
             </div>
 
             <div className="col-span-2">
-              <DocCard title={t('Need help from team member?')}>
-                <a className="link" onClick={showUserModal}>
-                  {t('Invite and Collaborate')}
-                </a>
-              </DocCard>
+              <CollabCard showUserModal={showUserModal} />
 
-              <DocCard title={t('Project Key')}>
-                <div className="p-2 rounded bg-white flex justify-between items-center">
-                  {site.projectKey}
-                  <CopyButton content={site.projectKey} />
-                </div>
-              </DocCard>
+              <ProjectKeyCard projectKey={site.projectKey} />
             </div>
           </div>
         );

frontend/app/components/Onboarding/components/OnboardingTabs/OnboardingTabs.tsx

@@ -3,6 +3,7 @@ import { Tabs, Icon, CopyButton } from 'UI';
 import DocCard from 'Shared/DocCard/DocCard';
 import { useModal } from 'App/components/Modal';
 import UserForm from 'App/components/Client/Users/components/UserForm/UserForm';
+import { CollabCard, ProjectKeyCard } from "./Callouts";
 import InstallDocs from './InstallDocs';
 import ProjectCodeSnippet from './ProjectCodeSnippet';
 import { useTranslation } from 'react-i18next';
@@ -37,20 +38,9 @@ function TrackingCodeModal(props: Props) {
             </div>
 
             <div className="col-span-2">
-              <DocCard title="Need help from team member?">
-                <a className="link" onClick={showUserModal}>
-                  {t('Invite and Collaborate')}
-                </a>
-              </DocCard>
-              <DocCard title="Project Key">
-                <div className="rounded bg-white px-2 py-1 flex items-center justify-between">
-                  <span>{site.projectKey}</span>
-                  <CopyButton
-                    content={site.projectKey}
-                    className="capitalize"
-                  />
-                </div>
-              </DocCard>
+              <CollabCard showUserModal={showUserModal} />
+
+              <ProjectKeyCard projectKey={site.projectKey} />
               <DocCard title="Other ways to install">
                 <a
                   className="link flex items-center"
@@ -77,18 +67,9 @@ function TrackingCodeModal(props: Props) {
             </div>
 
             <div className="col-span-2">
-              <DocCard title="Need help from team member?">
-                <a className="link" onClick={showUserModal}>
-                  {t('Invite and Collaborate')}
-                </a>
-              </DocCard>
+              <CollabCard showUserModal={showUserModal} />
 
-              <DocCard title="Project Key">
-                <div className="p-2 rounded bg-white flex justify-between items-center">
-                  {site.projectKey}
-                  <CopyButton content={site.projectKey} />
-                </div>
-              </DocCard>
+              <ProjectKeyCard projectKey={site.projectKey} />
             </div>
           </div>
         );

frontend/app/components/Onboarding/components/SideMenu.tsx

@@ -41,7 +41,7 @@ function SideMenu(props: Props) {
         <Menu
           mode="inline"
           onClick={handleClick}
-          style={{ marginTop: '8px', border: 'none' }}
+          style={{ border: 'none' }}
           selectedKeys={activeTab ? [activeTab] : []}
         >
           <Menu.Item