.github/workflows/api-ee.yaml

@@ -10,6 +10,8 @@ on:
     branches:
       - dev
       - api-*
+      - v1.11.0-patch
+      - actions_test
     paths:
       - "ee/api/**"
       - "api/**"

.github/workflows/api.yaml

@@ -10,6 +10,7 @@ on:
     branches:
       - dev
       - api-*
+      - v1.11.0-patch
     paths:
       - "api/**"
       - "!api/.gitignore"

.github/workflows/assist-ee.yaml

@@ -9,6 +9,7 @@ on:
   push:
     branches:
       - dev
+      - api-*
     paths:
       - "ee/assist/**"
       - "assist/**"

.github/workflows/assist-stats.yaml

@@ -15,7 +15,7 @@ on:
       - "!assist-stats/*-dev.sh"
       - "!assist-stats/requirements-*.txt"
 
-name: Build and Deploy Assist Stats ee
+name: Build and Deploy Assist Stats
 
 jobs:
   deploy:
@@ -123,9 +123,8 @@ jobs:
               tag: ${IMAGE_TAG}
           EOF
 
-          export IMAGE_TAG=${IMAGE_TAG}
           # Update changed image tag
-          yq '.utilities.apiCrons.assiststats.image.tag = strenv(IMAGE_TAG)' -i /tmp/image_override.yaml
+          sed -i "/assist-stats/{n;n;n;s/.*/    tag: ${IMAGE_TAG}/}" /tmp/image_override.yaml
 
           cat /tmp/image_override.yaml
           # Deploy command

.github/workflows/assist.yaml

@@ -9,6 +9,7 @@ on:
   push:
     branches:
       - dev
+      - api-*
     paths:
       - "assist/**"
       - "!assist/.gitignore"

.github/workflows/crons-ee.yaml

@@ -10,6 +10,7 @@ on:
     branches:
       - dev
       - api-*
+      - v1.11.0-patch
     paths:
       - "ee/api/**"
       - "api/**"
@@ -100,32 +101,33 @@ jobs:
             docker push $DOCKER_REPO/$image:$IMAGE_TAG 
           done
       - name: Creating old image input
-        env:
-          # We're not passing -ee flag, because helm will add that.
-          IMAGE_TAG: ${{ github.ref_name }}_${{ github.sha }}
         run: |
-          cd scripts/helmcharts/
-          cat <<EOF>/tmp/image_override.yaml
-          image: &image
-            tag: "${IMAGE_TAG}"
-          utilities:
-            apiCrons:
-              assiststats:
-                image: *image
-              report:
-                image: *image
-              sessionsCleaner:
-                image: *image
-              projectsStats:
-                image: *image
-              fixProjectsStats:
-                image: *image
+          #
+          # 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: |
           cd scripts/helmcharts/
 
+          # Update changed image tag
+          sed -i "/crons/{n;n;n;s/.*/    tag: ${IMAGE_TAG}/}" /tmp/image_override.yaml
+
           cat /tmp/image_override.yaml
           # Deploy command
           mkdir -p /tmp/charts
@@ -135,6 +137,8 @@ jobs:
           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
 
       - name: Alert slack

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

@@ -1,189 +0,0 @@
-# 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,6 +2,7 @@
 
 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).'
@@ -19,20 +20,12 @@ jobs:
       DEPOT_PROJECT_ID: ${{ secrets.DEPOT_PROJECT_ID }}
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v2
       with:
-        fetch-depth: 0
-        token: ${{ secrets.GITHUB_TOKEN }}
+        fetch-depth: 1
     - name: Rebase with main branch, to make sure the code has latest main changes
-      if: github.ref != 'refs/heads/main'
       run: |
-        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
+        git pull --rebase origin main
 
     - name: Downloading yq
       run: |
@@ -55,8 +48,6 @@ 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
@@ -74,168 +65,78 @@ 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: |
-        #!/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"
+        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
         }
-
-        # 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 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
+          }
         }
-
-        # 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
+        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
         }
-
-        # 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"
-        
+        # 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
 
     - name: Create Pull Request
       uses: repo-sync/pull-request@v2
@@ -246,7 +147,8 @@ 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, tag update job will run automatically.
+          Once this PR is merged, To update the latest tag, run the following workflow.
+          https://github.com/openreplay/openreplay/actions/workflows/update-tag.yaml
 
     # - name: Debug Job
     #   if: ${{ failure() }}

.github/workflows/peers-ee.yaml

@@ -1,4 +1,4 @@
-# This action will push the assist changes to aws
+# This action will push the peers changes to aws
 on:
   workflow_dispatch:
     inputs:
@@ -9,10 +9,14 @@ on:
   push:
     branches:
       - dev
+      - api-*
     paths:
-      - "ee/assist-server/**"
+      - "ee/peers/**"
+      - "peers/**"
+      - "!peers/.gitignore"
+      - "!peers/*-dev.sh"
 
-name: Build and Deploy Assist-Server EE
+name: Build and Deploy Peers EE
 
 jobs:
   deploy:
@@ -53,7 +57,12 @@ jobs:
           kubeconfig: ${{ secrets.EE_KUBECONFIG }} # Use content of kubeconfig in secret.
         id: setcontext
 
-      - name: Building and Pushing Assist-Server image
+      # Caching docker images
+      - uses: satackey/action-docker-layer-caching@v0.0.11
+        # Ignore the failure of a step and avoid terminating the job.
+        continue-on-error: true
+
+      - name: Building and Pushing peers image
         id: build-image
         env:
           DOCKER_REPO: ${{ secrets.EE_REGISTRY_URL }}
@@ -61,11 +70,11 @@ jobs:
           ENVIRONMENT: staging
         run: |
           skip_security_checks=${{ github.event.inputs.skip_security_checks }}
-          cd assist-server
+          cd peers
           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")
+            images=("peers")
             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
@@ -76,7 +85,7 @@ jobs:
           } && {
             echo "Skipping Security Checks"
           }
-          images=("assist-server")
+          images=("peers")
           for image in ${images[*]};do
             docker push $DOCKER_REPO/$image:$IMAGE_TAG 
           done
@@ -100,23 +109,43 @@ jobs:
               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
+          sed -i "/peers/{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/
+          mv openreplay/charts/{ingress-nginx,peers,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
+
+      - name: Alert slack
+        if: ${{ failure() }}
+        uses: rtCamp/action-slack-notify@v2
+        env:
+          SLACK_CHANNEL: ee
+          SLACK_TITLE: "Failed ${{ github.workflow }}"
+          SLACK_COLOR: ${{ job.status }} # or a specific color like 'good' or '#ff00ff'
+          SLACK_WEBHOOK: ${{ secrets.SLACK_WEB_HOOK }}
+          SLACK_USERNAME: "OR Bot"
+          SLACK_MESSAGE: "Build failed :bomb:"
+
+    # - name: Debug Job
+    #   # if: ${{ failure() }}
+    #   uses: mxschmitt/action-tmate@v3
+    #   env:
+    #     DOCKER_REPO: ${{ secrets.EE_REGISTRY_URL }}
+    #     IMAGE_TAG: ${{ github.sha }}-ee
+    #     ENVIRONMENT: staging
+    #    with:
+    #      iimit-access-to-actor: true

.github/workflows/peers.yaml

@@ -0,0 +1,149 @@
+# This action will push the peers 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
+      - api-*
+    paths:
+      - "peers/**"
+      - "!peers/.gitignore"
+      - "!peers/*-dev.sh"
+
+name: Build and Deploy Peers
+
+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.OSS_DOMAIN_NAME }}
+          jwt_refresh_secret: ${{ secrets.JWT_REFRESH_SECRET }}
+          jwt_secret: ${{ secrets.OSS_JWT_SECRET }}
+          jwt_spot_refresh_secret: ${{ secrets.JWT_SPOT_REFRESH_SECRET }}
+          jwt_spot_secret: ${{ secrets.JWT_SPOT_SECRET }}
+          license_key: ${{ secrets.OSS_LICENSE_KEY }}
+          minio_access_key: ${{ secrets.OSS_MINIO_ACCESS_KEY }}
+          minio_secret_key: ${{ secrets.OSS_MINIO_SECRET_KEY }}
+          pg_password: ${{ secrets.OSS_PG_PASSWORD }}
+          registry_url: ${{ secrets.OSS_REGISTRY_URL }}
+        name: Update Keys
+
+      - name: Docker login
+        run: |
+          docker login ${{ secrets.OSS_REGISTRY_URL }} -u ${{ secrets.OSS_DOCKER_USERNAME }} -p "${{ secrets.OSS_REGISTRY_TOKEN }}"
+
+      - uses: azure/k8s-set-context@v1
+        with:
+          method: kubeconfig
+          kubeconfig: ${{ secrets.OSS_KUBECONFIG }} # Use content of kubeconfig in secret.
+        id: setcontext
+
+      # Caching docker images
+      - uses: satackey/action-docker-layer-caching@v0.0.11
+        # Ignore the failure of a step and avoid terminating the job.
+        continue-on-error: true
+
+      - name: Building and Pushing peers image
+        id: build-image
+        env:
+          DOCKER_REPO: ${{ secrets.OSS_REGISTRY_URL }}
+          IMAGE_TAG: ${{ github.ref_name }}_${{ github.sha }}
+          ENVIRONMENT: staging
+        run: |
+          skip_security_checks=${{ github.event.inputs.skip_security_checks }}
+          cd peers
+          PUSH_IMAGE=0 bash -x ./build.sh
+          [[ "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=("peers")
+            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=("peers")
+          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:
+              tag: ${image_array[1]}
+          EOF
+          done
+
+      - name: Deploy to kubernetes
+        run: |
+          cd scripts/helmcharts/
+
+          # Update changed image tag
+          sed -i "/peers/{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,peers,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 | kubectl apply -n app -f -
+        env:
+          DOCKER_REPO: ${{ secrets.OSS_REGISTRY_URL }}
+          IMAGE_TAG: ${{ github.ref_name }}_${{ github.sha }}
+          ENVIRONMENT: staging
+
+      - name: Alert slack
+        if: ${{ failure() }}
+        uses: rtCamp/action-slack-notify@v2
+        env:
+          SLACK_CHANNEL: foss
+          SLACK_TITLE: "Failed ${{ github.workflow }}"
+          SLACK_COLOR: ${{ job.status }} # or a specific color like 'good' or '#ff00ff'
+          SLACK_WEBHOOK: ${{ secrets.SLACK_WEB_HOOK }}
+          SLACK_USERNAME: "OR Bot"
+          SLACK_MESSAGE: "Build failed :bomb:"
+
+    # - name: Debug Job
+    #   # if: ${{ failure() }}
+    #   uses: mxschmitt/action-tmate@v3
+    #   env:
+    #     DOCKER_REPO: ${{ secrets.EE_REGISTRY_URL }}
+    #     IMAGE_TAG: ${{ github.sha }}-ee
+    #     ENVIRONMENT: staging
+    #    with:
+    #      limit-access-to-actor: true

.github/workflows/release-deployment.yaml

@@ -1,103 +0,0 @@
-name: Release Deployment
-
-on:
-  workflow_dispatch:
-    inputs:
-      services:
-        description: 'Comma-separated list of services to deploy. eg: frontend,api,sink'
-        required: true
-      branch:
-        description: 'Branch to deploy (defaults to dev)'
-        required: false
-        default: 'dev'
-
-env:
-  IMAGE_REGISTRY_URL: ${{ secrets.OSS_REGISTRY_URL }}
-  DEPOT_PROJECT_ID: ${{ secrets.DEPOT_PROJECT_ID }}
-  DEPOT_TOKEN: ${{ secrets.DEPOT_TOKEN }}
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout code
-      uses: actions/checkout@v3
-      with:
-        ref: ${{ github.event.inputs.branch }}
-    - name: Docker login
-      run: |
-        docker login $IMAGE_REGISTRY_URL -u ${{ secrets.OSS_DOCKER_USERNAME }} -p "${{ secrets.OSS_REGISTRY_TOKEN }}"
-
-    - name: Set image tag with branch info
-      run: |
-        SHORT_SHA=$(git rev-parse --short HEAD)
-        echo "IMAGE_TAG=${{ github.event.inputs.branch }}-${SHORT_SHA}" >> $GITHUB_ENV
-        echo "Using image tag: $IMAGE_TAG"
-
-    - uses: depot/setup-action@v1
-
-    - name: Build and push Docker images
-      run: |
-        # Parse the comma-separated services list into an array
-        IFS=',' read -ra SERVICES <<< "${{ github.event.inputs.services }}"
-        working_dir=$(pwd)
-        
-        # Define backend services (consider moving this to workflow inputs or repo config)
-        ls backend/cmd >> /tmp/backend.txt
-        BUILD_SCRIPT_NAME="build.sh"
-        
-        for SERVICE in "${SERVICES[@]}"; do
-          # Check if service is backend
-          if grep -q $SERVICE /tmp/backend.txt; then 
-            cd $working_dir/backend 
-            foss_build_args="nil $SERVICE"
-            ee_build_args="ee $SERVICE"
-          else 
-            cd $working_dir
-            [[ $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  
-          {
-            echo IMAGE_TAG=$IMAGE_TAG DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=amd64 DOCKER_REPO=$IMAGE_REGISTRY_URL PUSH_IMAGE=0 bash ${BUILD_SCRIPT_NAME} $foss_build_args
-            IMAGE_TAG=$IMAGE_TAG DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=amd64 DOCKER_REPO=$IMAGE_REGISTRY_URL PUSH_IMAGE=0 bash ${BUILD_SCRIPT_NAME} $foss_build_args
-          }&
-          {
-            echo IMAGE_TAG=${IMAGE_TAG}-ee DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=amd64 DOCKER_REPO=$IMAGE_REGISTRY_URL PUSH_IMAGE=0 bash ${BUILD_SCRIPT_NAME} $ee_build_args
-            IMAGE_TAG=${IMAGE_TAG}-ee DOCKER_RUNTIME="depot" DOCKER_BUILD_ARGS="--push" ARCH=amd64 DOCKER_REPO=$IMAGE_REGISTRY_URL PUSH_IMAGE=0 bash ${BUILD_SCRIPT_NAME} $ee_build_args
-          }&
-        done
-        wait
-          
-    - uses: azure/k8s-set-context@v1
-      name: Using ee release cluster
-      with:
-        method: kubeconfig
-        kubeconfig: ${{ secrets.EE_RELEASE_KUBECONFIG }}
-
-    - name: Deploy to ee release Kubernetes
-      run: |
-        echo "Deploying services to EE cluster: ${{ github.event.inputs.services }}"
-        IFS=',' read -ra SERVICES <<< "${{ github.event.inputs.services }}" 
-        for SERVICE in "${SERVICES[@]}"; do
-          SERVICE=$(echo $SERVICE | xargs) # Trim whitespace
-          echo "Deploying $SERVICE to EE cluster with image tag: ${IMAGE_TAG}"
-          kubectl set image deployment/$SERVICE-openreplay -n app $SERVICE=${IMAGE_REGISTRY_URL}/$SERVICE:${IMAGE_TAG}-ee
-        done
-
-    - uses: azure/k8s-set-context@v1
-      name: Using foss release cluster
-      with:
-        method: kubeconfig
-        kubeconfig: ${{ secrets.FOSS_RELEASE_KUBECONFIG }}
-
-    - name: Deploy to FOSS release Kubernetes
-      run: |
-        echo "Deploying services to FOSS cluster: ${{ github.event.inputs.services }}"
-        IFS=',' read -ra SERVICES <<< "${{ github.event.inputs.services }}" 
-        for SERVICE in "${SERVICES[@]}"; do
-          SERVICE=$(echo $SERVICE | xargs) # Trim whitespace
-          echo "Deploying $SERVICE to FOSS cluster with image tag: ${IMAGE_TAG}"
-          echo "Deploying $SERVICE to FOSS cluster with image tag: ${IMAGE_TAG}"
-          kubectl set image deployment/$SERVICE-openreplay -n app $SERVICE=${IMAGE_REGISTRY_URL}/$SERVICE:${IMAGE_TAG}
-        done

.github/workflows/sourcemaps-reader-ee.yaml

@@ -1,4 +1,4 @@
-# This action will push the sourcemapreader changes to ee
+# This action will push the sourcemapreader changes to aws
 on:
   workflow_dispatch:
     inputs:
@@ -9,13 +9,13 @@ on:
   push:
     branches:
       - dev
+      - api-*
     paths:
-      - "ee/sourcemap-reader/**"
       - "sourcemap-reader/**"
       - "!sourcemap-reader/.gitignore"
       - "!sourcemap-reader/*-dev.sh"
 
-name: Build and Deploy sourcemap-reader EE
+name: Build and Deploy sourcemap-reader
 
 jobs:
   deploy:
@@ -64,7 +64,7 @@ jobs:
       - name: Building and Pushing sourcemaps-reader image
         id: build-image
         env:
-          DOCKER_REPO: ${{ secrets.EE_REGISTRY_URL }}
+          DOCKER_REPO: ${{ secrets.OSS_REGISTRY_URL }}
           IMAGE_TAG: ${{ github.ref_name }}_${{ github.sha }}-ee
           ENVIRONMENT: staging
         run: |
@@ -132,7 +132,7 @@ jobs:
         if: ${{ failure() }}
         uses: rtCamp/action-slack-notify@v2
         env:
-          SLACK_CHANNEL: ee
+          SLACK_CHANNEL: foss
           SLACK_TITLE: "Failed ${{ github.workflow }}"
           SLACK_COLOR: ${{ job.status }} # or a specific color like 'good' or '#ff00ff'
           SLACK_WEBHOOK: ${{ secrets.SLACK_WEB_HOOK }}

.github/workflows/sourcemaps-reader.yaml

@@ -9,6 +9,7 @@ on:
   push:
     branches:
       - dev
+      - api-*
     paths:
       - "sourcemap-reader/**"
       - "!sourcemap-reader/.gitignore"

.github/workflows/update-tag.yaml

@@ -1,42 +1,35 @@
 on:
-  pull_request:
-    types: [closed]
-    branches:
-      - main
-name: Release tag update --force
+  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
 
 jobs:
   deploy:
     name: Build Patch from main
     runs-on: ubuntu-latest
-    if: ${{ (github.event_name == 'pull_request' && github.event.pull_request.merged == true) || github.event.inputs.services == 'true' }}
+    env:
+      DEPOT_TOKEN: ${{ secrets.DEPOT_TOKEN }}
+      DEPOT_PROJECT_ID: ${{ secrets.DEPOT_PROJECT_ID }}
     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 remote set-url origin https://x-access-token:${{ secrets.ACTIONS_COMMMIT_TOKEN }}@github.com/${{ github.repository }}.git
       - name: Push main branch to tag
         run: |
+          git fetch --tags
           git checkout main
-          echo "Updating tag ${{ env.LATEST_TAG }} to point to latest commit on main"
-          git push origin HEAD:refs/tags/${{ env.LATEST_TAG }} --force
+          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

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2021-2025 Asayer, Inc dba OpenReplay
+Copyright (c) 2021-2024 Asayer, Inc dba OpenReplay
 
 OpenReplay monorepo uses multiple licenses. Portions of this software are licensed as follows:
 - All content that resides under the "ee/" directory of this repository, is licensed under the license defined in "ee/LICENSE".

api/Dockerfile

@@ -1,17 +1,10 @@
-FROM python:3.12-alpine AS builder
-LABEL maintainer="Rajesh Rajendran<rjshrjndrn@gmail.com>"
-LABEL maintainer="KRAIEM Taha Yassine<tahayk2@gmail.com>"
-
-RUN apk add --no-cache build-base
-WORKDIR /work
-COPY requirements.txt ./requirements.txt
-RUN pip install --no-cache-dir --upgrade uv && \
-  export UV_SYSTEM_PYTHON=true && \
-  uv pip install --no-cache-dir --upgrade pip setuptools wheel && \
-  uv pip install --no-cache-dir --upgrade -r requirements.txt
-
-FROM python:3.12-alpine
+FROM python:3.11-alpine
+LABEL Maintainer="Rajesh Rajendran<rjshrjndrn@gmail.com>"
+LABEL Maintainer="KRAIEM Taha Yassine<tahayk2@gmail.com>"
 ARG GIT_SHA
+LABEL GIT_SHA=$GIT_SHA
+
+RUN apk add --no-cache build-base tini
 ARG envarg
 # Add Tini
 # Startup daemon
@@ -21,11 +14,19 @@ ENV SOURCE_MAP_VERSION=0.7.4 \
   PRIVATE_ENDPOINTS=false \
   ENTERPRISE_BUILD=${envarg} \
   GIT_SHA=$GIT_SHA
-COPY --from=builder /usr/local/lib/python3.12/site-packages /usr/local/lib/python3.12/site-packages
-COPY --from=builder /usr/local/bin /usr/local/bin
+
 WORKDIR /work
+COPY requirements.txt ./requirements.txt
+RUN pip install --no-cache-dir --upgrade uv
+RUN uv pip install --no-cache-dir --upgrade pip setuptools wheel --system
+RUN uv pip install --no-cache-dir --upgrade -r requirements.txt --system
+
 COPY . .
-RUN apk add --no-cache tini && mv env.default .env
+RUN mv env.default .env
+
+RUN adduser -u 1001 openreplay -D
+USER 1001
 
 ENTRYPOINT ["/sbin/tini", "--"]
-CMD ["./entrypoint.sh"]
+CMD ./entrypoint.sh
+

api/Dockerfile_alerts

@@ -1,4 +1,4 @@
-FROM python:3.12-alpine
+FROM python:3.11-alpine
 LABEL Maintainer="Rajesh Rajendran<rjshrjndrn@gmail.com>"
 LABEL Maintainer="KRAIEM Taha Yassine<tahayk2@gmail.com>"
 ARG GIT_SHA

api/Pipfile

@@ -4,21 +4,22 @@ verify_ssl = true
 name = "pypi"
 
 [packages]
-urllib3 = "==2.3.0"
+sqlparse = "==0.5.2"
+urllib3 = "==2.2.3"
 requests = "==2.32.3"
-boto3 = "==1.36.12"
+boto3 = "==1.35.76"
 pyjwt = "==2.10.1"
 psycopg2-binary = "==2.9.10"
-psycopg = {extras = ["pool", "binary"], version = "==3.2.4"}
+psycopg = {extras = ["binary", "pool"], version = "==3.2.3"}
 clickhouse-driver = {extras = ["lz4"], version = "==0.2.9"}
-clickhouse-connect = "==0.8.15"
-elasticsearch = "==8.17.1"
+clickhouse-connect = "==0.8.9"
+elasticsearch = "==8.16.0"
 jira = "==3.8.0"
-cachetools = "==5.5.1"
-fastapi = "==0.115.8"
-uvicorn = {extras = ["standard"], version = "==0.34.0"}
+cachetools = "==5.5.0"
+fastapi = "==0.115.6"
+uvicorn = {extras = ["standard"], version = "==0.32.1"}
 python-decouple = "==3.8"
-pydantic = {extras = ["email"], version = "==2.10.6"}
+pydantic = {extras = ["email"], version = "==2.10.3"}
 apscheduler = "==3.11.0"
 redis = "==5.2.1"
 
@@ -26,4 +27,3 @@ redis = "==5.2.1"
 
 [requires]
 python_version = "3.12"
-python_full_version = "3.12.8"

api/app_alerts.py

@@ -12,7 +12,7 @@ from chalicelib.utils import pg_client
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     # Startup
-    ap_logger.info(">>>>> starting up <<<<<")
+    logging.info(">>>>> starting up <<<<<")
     await pg_client.init()
     app.schedule.start()
     app.schedule.add_job(id="alerts_processor", **{"func": alerts_processor.process, "trigger": "interval",
@@ -27,22 +27,14 @@ async def lifespan(app: FastAPI):
     yield
 
     # Shutdown
-    ap_logger.info(">>>>> shutting down <<<<<")
+    logging.info(">>>>> shutting down <<<<<")
     app.schedule.shutdown(wait=False)
     await pg_client.terminate()
 
 
-loglevel = config("LOGLEVEL", default=logging.INFO)
-print(f">Loglevel set to: {loglevel}")
-logging.basicConfig(level=loglevel)
-ap_logger = logging.getLogger('apscheduler')
-ap_logger.setLevel(loglevel)
-
 app = FastAPI(root_path=config("root_path", default="/alerts"), docs_url=config("docs_url", default=""),
               redoc_url=config("redoc_url", default=""), lifespan=lifespan)
-
-app.schedule = AsyncIOScheduler()
-ap_logger.info("============= ALERTS =============")
+logging.info("============= ALERTS =============")
 
 
 @app.get("/")
@@ -58,8 +50,17 @@ async def get_health_status():
     }}
 
 
+app.schedule = AsyncIOScheduler()
+
+loglevel = config("LOGLEVEL", default=logging.INFO)
+print(f">Loglevel set to: {loglevel}")
+logging.basicConfig(level=loglevel)
+ap_logger = logging.getLogger('apscheduler')
+ap_logger.setLevel(loglevel)
+app.schedule = AsyncIOScheduler()
+
 if config("LOCAL_DEV", default=False, cast=bool):
     @app.get('/trigger', tags=["private"])
     async def trigger_main_cron():
-        ap_logger.info("Triggering main cron")
+        logging.info("Triggering main cron")
         alerts_processor.process()

api/chalicelib/core/alerts/alerts_processor.py

@@ -4,8 +4,7 @@ from pydantic_core._pydantic_core import ValidationError
 
 import schemas
 from chalicelib.core.alerts import alerts, alerts_listener
-from chalicelib.core.alerts.modules import alert_helpers
-from chalicelib.core.sessions import sessions_pg as sessions
+from chalicelib.core.alerts.modules import sessions, alert_helpers
 from chalicelib.utils import pg_client
 from chalicelib.utils.TimeUTC import TimeUTC
 
@@ -132,7 +131,6 @@ def Build(a):
 
 
 def process():
-    logger.info("> processing alerts on PG")
     notifications = []
     all_alerts = alerts_listener.get_all_alerts()
     with pg_client.PostgresClient() as cur:

api/chalicelib/core/alerts/alerts_processor_ch.py

@@ -3,11 +3,10 @@ import logging
 from pydantic_core._pydantic_core import ValidationError
 
 import schemas
+from chalicelib.core.alerts import alerts, alerts_listener
+from chalicelib.core.alerts.modules import sessions, alert_helpers
 from chalicelib.utils import pg_client, ch_client, exp_ch_helper
 from chalicelib.utils.TimeUTC import TimeUTC
-from chalicelib.core.alerts import alerts, alerts_listener
-from chalicelib.core.alerts.modules import alert_helpers
-from chalicelib.core.sessions import sessions_ch as sessions
 
 logger = logging.getLogger(__name__)
 
@@ -156,7 +155,6 @@ def Build(a):
 
 
 def process():
-    logger.info("> processing alerts on CH")
     notifications = []
     all_alerts = alerts_listener.get_all_alerts()
     with pg_client.PostgresClient() as cur, ch_client.ClickHouseClient() as ch_cur:
@@ -166,7 +164,7 @@ def process():
             if alert_helpers.can_check(alert):
                 query, params = Build(alert)
                 try:
-                    query = ch_cur.format(query=query, parameters=params)
+                    query = ch_cur.format(query, params)
                 except Exception as e:
                     logger.error(
                         f"!!!Error while building alert query for alertId:{alert['alertId']} name: {alert['name']}")
@@ -175,7 +173,7 @@ def process():
                 logger.debug(alert)
                 logger.debug(query)
                 try:
-                    result = ch_cur.execute(query=query)
+                    result = ch_cur.execute(query)
                     if len(result) > 0:
                         result = result[0]
 

api/chalicelib/core/alerts/modules/__init__.py

@@ -1,3 +1,9 @@
+from decouple import config
+
 TENANT_ID = "-1"
+if config("EXP_ALERTS", cast=bool, default=False):
+    from chalicelib.core.sessions import sessions_ch as sessions
+else:
+    from chalicelib.core.sessions import sessions
 
 from . import helpers as alert_helpers

api/chalicelib/core/assist.py

@@ -1,4 +1,3 @@
-import logging
 from os import access, R_OK
 from os.path import exists as path_exists, getsize
 
@@ -11,8 +10,6 @@ import schemas
 from chalicelib.core import projects
 from chalicelib.utils.TimeUTC import TimeUTC
 
-logger = logging.getLogger(__name__)
-
 ASSIST_KEY = config("ASSIST_KEY")
 ASSIST_URL = config("ASSIST_URL") % ASSIST_KEY
 
@@ -55,21 +52,21 @@ def __get_live_sessions_ws(project_id, data):
         results = requests.post(ASSIST_URL + config("assist") + f"/{project_key}",
                                 json=data, timeout=config("assistTimeout", cast=int, default=5))
         if results.status_code != 200:
-            logger.error(f"!! issue with the peer-server code:{results.status_code} for __get_live_sessions_ws")
-            logger.error(results.text)
+            print(f"!! issue with the peer-server code:{results.status_code} for __get_live_sessions_ws")
+            print(results.text)
             return {"total": 0, "sessions": []}
         live_peers = results.json().get("data", [])
     except requests.exceptions.Timeout:
-        logger.error("!! Timeout getting Assist response")
+        print("!! Timeout getting Assist response")
         live_peers = {"total": 0, "sessions": []}
     except Exception as e:
-        logger.error("!! Issue getting Live-Assist response")
-        logger.exception(e)
-        logger.error("expected JSON, received:")
+        print("!! Issue getting Live-Assist response")
+        print(str(e))
+        print("expected JSON, received:")
         try:
-            logger.error(results.text)
+            print(results.text)
         except:
-            logger.error("couldn't get response")
+            print("couldn't get response")
         live_peers = {"total": 0, "sessions": []}
     _live_peers = live_peers
     if "sessions" in live_peers:
@@ -105,8 +102,8 @@ def get_live_session_by_id(project_id, session_id):
         results = requests.get(ASSIST_URL + config("assist") + f"/{project_key}/{session_id}",
                                timeout=config("assistTimeout", cast=int, default=5))
         if results.status_code != 200:
-            logger.error(f"!! issue with the peer-server code:{results.status_code} for get_live_session_by_id")
-            logger.error(results.text)
+            print(f"!! issue with the peer-server code:{results.status_code} for get_live_session_by_id")
+            print(results.text)
             return None
         results = results.json().get("data")
         if results is None:
@@ -114,16 +111,16 @@ def get_live_session_by_id(project_id, session_id):
         results["live"] = True
         results["agentToken"] = __get_agent_token(project_id=project_id, project_key=project_key, session_id=session_id)
     except requests.exceptions.Timeout:
-        logger.error("!! Timeout getting Assist response")
+        print("!! Timeout getting Assist response")
         return None
     except Exception as e:
-        logger.error("!! Issue getting Assist response")
-        logger.exception(e)
-        logger.error("expected JSON, received:")
+        print("!! Issue getting Assist response")
+        print(str(e))
+        print("expected JSON, received:")
         try:
-            logger.error(results.text)
+            print(results.text)
         except:
-            logger.error("couldn't get response")
+            print("couldn't get response")
         return None
     return results
 
@@ -135,21 +132,21 @@ def is_live(project_id, session_id, project_key=None):
         results = requests.get(ASSIST_URL + config("assistList") + f"/{project_key}/{session_id}",
                                timeout=config("assistTimeout", cast=int, default=5))
         if results.status_code != 200:
-            logger.error(f"!! issue with the peer-server code:{results.status_code} for is_live")
-            logger.error(results.text)
+            print(f"!! issue with the peer-server code:{results.status_code} for is_live")
+            print(results.text)
             return False
         results = results.json().get("data")
     except requests.exceptions.Timeout:
-        logger.error("!! Timeout getting Assist response")
+        print("!! Timeout getting Assist response")
         return False
     except Exception as e:
-        logger.error("!! Issue getting Assist response")
-        logger.exception(e)
-        logger.error("expected JSON, received:")
+        print("!! Issue getting Assist response")
+        print(str(e))
+        print("expected JSON, received:")
         try:
-            logger.error(results.text)
+            print(results.text)
         except:
-            logger.error("couldn't get response")
+            print("couldn't get response")
         return False
     return str(session_id) == results
 
@@ -164,21 +161,21 @@ def autocomplete(project_id, q: str, key: str = None):
             ASSIST_URL + config("assistList") + f"/{project_key}/autocomplete",
             params=params, timeout=config("assistTimeout", cast=int, default=5))
         if results.status_code != 200:
-            logger.error(f"!! issue with the peer-server code:{results.status_code} for autocomplete")
-            logger.error(results.text)
+            print(f"!! issue with the peer-server code:{results.status_code} for autocomplete")
+            print(results.text)
             return {"errors": [f"Something went wrong wile calling assist:{results.text}"]}
         results = results.json().get("data", [])
     except requests.exceptions.Timeout:
-        logger.error("!! Timeout getting Assist response")
+        print("!! Timeout getting Assist response")
         return {"errors": ["Assist request timeout"]}
     except Exception as e:
-        logger.error("!! Issue getting Assist response")
-        logger.exception(e)
-        logger.error("expected JSON, received:")
+        print("!! Issue getting Assist response")
+        print(str(e))
+        print("expected JSON, received:")
         try:
-            logger.error(results.text)
+            print(results.text)
         except:
-            logger.error("couldn't get response")
+            print("couldn't get response")
         return {"errors": ["Something went wrong wile calling assist"]}
     for r in results:
         r["type"] = __change_keys(r["type"])
@@ -242,24 +239,24 @@ def session_exists(project_id, session_id):
         results = requests.get(ASSIST_URL + config("assist") + f"/{project_key}/{session_id}",
                                timeout=config("assistTimeout", cast=int, default=5))
         if results.status_code != 200:
-            logger.error(f"!! issue with the peer-server code:{results.status_code} for session_exists")
-            logger.error(results.text)
+            print(f"!! issue with the peer-server code:{results.status_code} for session_exists")
+            print(results.text)
             return None
         results = results.json().get("data")
         if results is None:
             return False
         return True
     except requests.exceptions.Timeout:
-        logger.error("!! Timeout getting Assist response")
+        print("!! Timeout getting Assist response")
         return False
     except Exception as e:
-        logger.error("!! Issue getting Assist response")
-        logger.exception(e)
-        logger.error("expected JSON, received:")
+        print("!! Issue getting Assist response")
+        print(str(e))
+        print("expected JSON, received:")
         try:
-            logger.error(results.text)
+            print(results.text)
         except:
-            logger.error("couldn't get response")
+            print("couldn't get response")
         return False
 
 

api/chalicelib/core/authorizers.py

@@ -37,7 +37,8 @@ def jwt_authorizer(scheme: str, token: str, leeway=0) -> dict | None:
         logger.debug("! JWT Expired signature")
         return None
     except BaseException as e:
-        logger.warning("! JWT Base Exception", exc_info=e)
+        logger.warning("! JWT Base Exception")
+        logger.debug(e)
         return None
     return payload
 
@@ -55,7 +56,8 @@ def jwt_refresh_authorizer(scheme: str, token: str):
         logger.debug("! JWT-refresh Expired signature")
         return None
     except BaseException as e:
-        logger.error("! JWT-refresh Base Exception", exc_info=e)
+        logger.warning("! JWT-refresh Base Exception")
+        logger.debug(e)
         return None
     return payload
 

api/chalicelib/core/autocomplete/__init__.py

@@ -0,0 +1,11 @@
+import logging
+
+from decouple import config
+
+logging.basicConfig(level=config("LOGLEVEL", default=logging.INFO))
+
+if config("EXP_AUTOCOMPLETE", cast=bool, default=False):
+    logging.info(">>> Using experimental autocomplete")
+    from . import autocomplete_ch as autocomplete
+else:
+    from . import autocomplete

api/chalicelib/core/autocomplete/autocomplete.py

@@ -85,8 +85,7 @@ def __generic_query(typename, value_length=None):
                       ORDER BY value"""
 
     if value_length is None or value_length > 2:
-        return f"""SELECT DISTINCT ON(value,type) value, type
-                   ((SELECT DISTINCT value, type
+        return f"""(SELECT DISTINCT value, type
                     FROM {TABLE}
                     WHERE
                       project_id = %(project_id)s
@@ -102,7 +101,7 @@ def __generic_query(typename, value_length=None):
                       AND type='{typename.upper()}'
                       AND value ILIKE %(value)s
                       ORDER BY value
-                    LIMIT 5)) AS raw;"""
+                    LIMIT 5);"""
     return f"""SELECT DISTINCT value, type
                 FROM {TABLE}
                 WHERE
@@ -125,7 +124,7 @@ def __generic_autocomplete(event: Event):
     return f
 
 
-def generic_autocomplete_metas(typename):
+def __generic_autocomplete_metas(typename):
     def f(project_id, text):
         with pg_client.PostgresClient() as cur:
             params = {"project_id": project_id, "value": helper.string_to_sql_like(text),
@@ -327,7 +326,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 DISTINCT ON(key, value) key, value, 'METADATA' AS TYPE
+                    SELECT 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/autocomplete/autocomplete_ch.py

@@ -59,10 +59,10 @@ def __get_autocomplete_table(value, project_id):
                   "c_list": tuple(c_list)}
         results = []
         try:
-            results = cur.execute(query=query, parameters=params)
+            results = cur.execute(query=query, params=params)
         except Exception as err:
             logger.exception("--------- CH AUTOCOMPLETE SEARCH QUERY EXCEPTION -----------")
-            logger.exception(cur.format(query=query, parameters=params))
+            logger.exception(cur.format(query=query, params=params))
             logger.exception("--------- PARAMS -----------")
             logger.exception(params)
             logger.exception("--------- VALUE -----------")
@@ -86,8 +86,7 @@ def __generic_query(typename, value_length=None):
                       ORDER BY value"""
 
     if value_length is None or value_length > 2:
-        return f"""SELECT DISTINCT ON(value, type) value, type
-                   FROM ((SELECT DISTINCT value, type
+        return f"""(SELECT DISTINCT value, type
                     FROM {TABLE}
                     WHERE
                       project_id = %(project_id)s
@@ -103,7 +102,7 @@ def __generic_query(typename, value_length=None):
                       AND type='{typename.upper()}'
                       AND value ILIKE %(value)s
                       ORDER BY value
-                    LIMIT 5)) AS raw;"""
+                    LIMIT 5);"""
     return f"""SELECT DISTINCT value, type
                 FROM {TABLE}
                 WHERE
@@ -120,13 +119,13 @@ def __generic_autocomplete(event: Event):
             query = __generic_query(event.ui_type, value_length=len(value))
             params = {"project_id": project_id, "value": helper.string_to_sql_like(value),
                       "svalue": helper.string_to_sql_like("^" + value)}
-            results = cur.execute(query=query, parameters=params)
+            results = cur.execute(query=query, params=params)
             return helper.list_to_camel_case(results)
 
     return f
 
 
-def generic_autocomplete_metas(typename):
+def __generic_autocomplete_metas(typename):
     def f(project_id, text):
         with ch_client.ClickHouseClient() as cur:
             params = {"project_id": project_id, "value": helper.string_to_sql_like(text),
@@ -138,7 +137,7 @@ def generic_autocomplete_metas(typename):
                     return []
 
             query = __generic_query(typename, value_length=len(text))
-            rows = cur.execute(query=query, parameters=params)
+            rows = cur.execute(query=query, params=params)
         return rows
 
     return f
@@ -258,25 +257,25 @@ 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 DISTINCT ON(key, value) key, value, 'METADATA' AS TYPE
+        query = cur.format(f"""SELECT 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),
+                                LIMIT 5;""", {"project_id": project_id, "value": helper.string_to_sql_like(value),
                                               "svalue": helper.string_to_sql_like("^" + value)})
         results = cur.execute(query)
     return helper.list_to_camel_case(results)
 
 
 TYPE_TO_COLUMN = {
-    schemas.EventType.CLICK: "`$properties`.label",
-    schemas.EventType.INPUT: "`$properties`.label",
-    schemas.EventType.LOCATION: "`$properties`.url_path",
-    schemas.EventType.CUSTOM: "`$properties`.name",
-    schemas.FetchFilterType.FETCH_URL: "`$properties`.url_path",
-    schemas.GraphqlFilterType.GRAPHQL_NAME: "`$properties`.name",
-    schemas.EventType.STATE_ACTION: "`$properties`.name",
+    schemas.EventType.CLICK: "label",
+    schemas.EventType.INPUT: "label",
+    schemas.EventType.LOCATION: "url_path",
+    schemas.EventType.CUSTOM: "name",
+    schemas.FetchFilterType.FETCH_URL: "url_path",
+    schemas.GraphqlFilterType.GRAPHQL_NAME: "name",
+    schemas.EventType.STATE_ACTION: "name",
     # For ERROR, sessions search is happening over name OR message,
     # for simplicity top 10 is using name only
-    schemas.EventType.ERROR: "`$properties`.name",
+    schemas.EventType.ERROR: "name",
     schemas.FilterType.USER_COUNTRY: "user_country",
     schemas.FilterType.USER_CITY: "user_city",
     schemas.FilterType.USER_STATE: "user_state",
@@ -326,9 +325,9 @@ def get_top_values(project_id, event_type, event_key=None):
             query = f"""WITH raw AS (SELECT DISTINCT {colname} AS c_value,
                                                      COUNT(1) OVER (PARTITION BY c_value) AS row_count,
                                                      COUNT(1) OVER ()                   AS total_count
-                                     FROM product_analytics.events
+                                     FROM experimental.events
                                      WHERE project_id = %(project_id)s
-                                       AND `$event_name` = '{event_type}'
+                                       AND event_type = '{event_type}'
                                        AND isNotNull(c_value)
                                        AND notEmpty(c_value)
                                      ORDER BY row_count DESC
@@ -336,5 +335,5 @@ def get_top_values(project_id, event_type, event_key=None):
                         SELECT c_value AS value, row_count, truncate(row_count * 100 / total_count,2) AS row_percentage
                         FROM raw;"""
         params = {"project_id": project_id}
-        results = cur.execute(query=query, parameters=params)
+        results = cur.execute(query=query, params=params)
         return helper.list_to_camel_case(results)

api/chalicelib/core/boarding.py

@@ -1,8 +1,8 @@
-from chalicelib.core import projects
-from chalicelib.core import users
-from chalicelib.core.log_tools import datadog, stackdriver, sentry
-from chalicelib.core.modules import TENANT_CONDITION
 from chalicelib.utils import pg_client
+from chalicelib.core import projects
+from chalicelib.core.log_tools import datadog, stackdriver, sentry
+
+from chalicelib.core import users
 
 
 def get_state(tenant_id):
@@ -13,61 +13,47 @@ def get_state(tenant_id):
 
         if len(pids) > 0:
             cur.execute(
-                cur.mogrify(
-                    """SELECT EXISTS((  SELECT 1
+                cur.mogrify("""SELECT EXISTS((  SELECT 1
                                                 FROM public.sessions AS s
                                                 WHERE s.project_id IN %(ids)s)) AS exists;""",
-                    {"ids": tuple(pids)},
-                )
+                            {"ids": tuple(pids)})
             )
             recorded = cur.fetchone()["exists"]
             meta = False
             if recorded:
-                query = cur.mogrify(
-                    f"""SELECT EXISTS((SELECT 1
+                cur.execute("""SELECT EXISTS((SELECT 1
                                FROM public.projects AS p
                                         LEFT JOIN LATERAL ( SELECT 1
                                                             FROM public.sessions
                                                             WHERE sessions.project_id = p.project_id
                                                               AND sessions.user_id IS NOT NULL
                                                             LIMIT 1) AS sessions(user_id) ON (TRUE)
-                               WHERE {TENANT_CONDITION} AND p.deleted_at ISNULL
+                               WHERE p.deleted_at ISNULL
                                  AND ( sessions.user_id IS NOT NULL OR p.metadata_1 IS NOT NULL
                                        OR p.metadata_2 IS NOT NULL OR p.metadata_3 IS NOT NULL
                                        OR p.metadata_4 IS NOT NULL OR p.metadata_5 IS NOT NULL
                                        OR p.metadata_6 IS NOT NULL OR p.metadata_7 IS NOT NULL
                                        OR p.metadata_8 IS NOT NULL OR p.metadata_9 IS NOT NULL
                                        OR p.metadata_10 IS NOT NULL )
-                                   )) AS exists;""",
-                    {"tenant_id": tenant_id},
-                )
-                cur.execute(query)
+                                   )) AS exists;""")
 
                 meta = cur.fetchone()["exists"]
 
     return [
-        {
-            "task": "Install OpenReplay",
-            "done": recorded,
-            "URL": "https://docs.openreplay.com/getting-started/quick-start",
-        },
-        {
-            "task": "Identify Users",
-            "done": meta,
-            "URL": "https://docs.openreplay.com/data-privacy-security/metadata",
-        },
-        {
-            "task": "Invite Team Members",
-            "done": len(users.get_members(tenant_id=tenant_id)) > 1,
-            "URL": "https://app.openreplay.com/client/manage-users",
-        },
-        {
-            "task": "Integrations",
-            "done": len(datadog.get_all(tenant_id=tenant_id)) > 0
-            or len(sentry.get_all(tenant_id=tenant_id)) > 0
-            or len(stackdriver.get_all(tenant_id=tenant_id)) > 0,
-            "URL": "https://docs.openreplay.com/integrations",
-        },
+        {"task": "Install OpenReplay",
+         "done": recorded,
+         "URL": "https://docs.openreplay.com/getting-started/quick-start"},
+        {"task": "Identify Users",
+         "done": meta,
+         "URL": "https://docs.openreplay.com/data-privacy-security/metadata"},
+        {"task": "Invite Team Members",
+         "done": len(users.get_members(tenant_id=tenant_id)) > 1,
+         "URL": "https://app.openreplay.com/client/manage-users"},
+        {"task": "Integrations",
+         "done": len(datadog.get_all(tenant_id=tenant_id)) > 0 \
+                 or len(sentry.get_all(tenant_id=tenant_id)) > 0 \
+                 or len(stackdriver.get_all(tenant_id=tenant_id)) > 0,
+         "URL": "https://docs.openreplay.com/integrations"}
     ]
 
 
@@ -78,66 +64,52 @@ def get_state_installing(tenant_id):
 
         if len(pids) > 0:
             cur.execute(
-                cur.mogrify(
-                    """SELECT EXISTS((  SELECT 1
+                cur.mogrify("""SELECT EXISTS((  SELECT 1
                                                 FROM public.sessions AS s
                                                 WHERE s.project_id IN %(ids)s)) AS exists;""",
-                    {"ids": tuple(pids)},
-                )
+                            {"ids": tuple(pids)})
             )
             recorded = cur.fetchone()["exists"]
 
-    return {
-        "task": "Install OpenReplay",
-        "done": recorded,
-        "URL": "https://docs.openreplay.com/getting-started/quick-start",
-    }
+    return {"task": "Install OpenReplay",
+            "done": recorded,
+            "URL": "https://docs.openreplay.com/getting-started/quick-start"}
 
 
 def get_state_identify_users(tenant_id):
     with pg_client.PostgresClient() as cur:
-        query = cur.mogrify(
-            f"""SELECT EXISTS((SELECT 1
+        cur.execute("""SELECT EXISTS((SELECT 1
                                        FROM public.projects AS p
                                                 LEFT JOIN LATERAL ( SELECT 1
                                                                     FROM public.sessions
                                                                     WHERE sessions.project_id = p.project_id
                                                                       AND sessions.user_id IS NOT NULL
                                                                     LIMIT 1) AS sessions(user_id) ON (TRUE)
-                                       WHERE {TENANT_CONDITION} AND p.deleted_at ISNULL
+                                       WHERE p.deleted_at ISNULL
                                          AND ( sessions.user_id IS NOT NULL OR p.metadata_1 IS NOT NULL
                                                OR p.metadata_2 IS NOT NULL OR p.metadata_3 IS NOT NULL
                                                OR p.metadata_4 IS NOT NULL OR p.metadata_5 IS NOT NULL
                                                OR p.metadata_6 IS NOT NULL OR p.metadata_7 IS NOT NULL
                                                OR p.metadata_8 IS NOT NULL OR p.metadata_9 IS NOT NULL
                                                OR p.metadata_10 IS NOT NULL )
-                                           )) AS exists;""",
-            {"tenant_id": tenant_id},
-        )
-        cur.execute(query)
+                                           )) AS exists;""")
 
         meta = cur.fetchone()["exists"]
 
-    return {
-        "task": "Identify Users",
-        "done": meta,
-        "URL": "https://docs.openreplay.com/data-privacy-security/metadata",
-    }
+    return {"task": "Identify Users",
+            "done": meta,
+            "URL": "https://docs.openreplay.com/data-privacy-security/metadata"}
 
 
 def get_state_manage_users(tenant_id):
-    return {
-        "task": "Invite Team Members",
-        "done": len(users.get_members(tenant_id=tenant_id)) > 1,
-        "URL": "https://app.openreplay.com/client/manage-users",
-    }
+    return {"task": "Invite Team Members",
+            "done": len(users.get_members(tenant_id=tenant_id)) > 1,
+            "URL": "https://app.openreplay.com/client/manage-users"}
 
 
 def get_state_integrations(tenant_id):
-    return {
-        "task": "Integrations",
-        "done": len(datadog.get_all(tenant_id=tenant_id)) > 0
-        or len(sentry.get_all(tenant_id=tenant_id)) > 0
-        or len(stackdriver.get_all(tenant_id=tenant_id)) > 0,
-        "URL": "https://docs.openreplay.com/integrations",
-    }
+    return {"task": "Integrations",
+            "done": len(datadog.get_all(tenant_id=tenant_id)) > 0 \
+                    or len(sentry.get_all(tenant_id=tenant_id)) > 0 \
+                    or len(stackdriver.get_all(tenant_id=tenant_id)) > 0,
+            "URL": "https://docs.openreplay.com/integrations"}

api/chalicelib/core/custom_metrics.py

@@ -4,10 +4,8 @@ import logging
 from fastapi import HTTPException, status
 
 import schemas
-from chalicelib.core import issues
-from chalicelib.core.errors import errors
-from chalicelib.core.metrics import heatmaps, product_analytics, funnels
-from chalicelib.core.sessions import sessions, sessions_search
+from chalicelib.core import funnels, errors, issues, heatmaps, product_analytics, custom_metrics_predefined
+from chalicelib.core.sessions import sessions
 from chalicelib.utils import helper, pg_client
 from chalicelib.utils.TimeUTC import TimeUTC
 
@@ -42,7 +40,7 @@ def __get_errors_list(project: schemas.ProjectContext, user_id, data: schemas.Ca
             "total": 0,
             "errors": []
         }
-    return errors.search(data.series[0].filter, project=project, user_id=user_id)
+    return errors.search(data.series[0].filter, project_id=project.project_id, user_id=user_id)
 
 
 def __get_sessions_list(project: schemas.ProjectContext, user_id, data: schemas.CardSchema):
@@ -52,11 +50,11 @@ def __get_sessions_list(project: schemas.ProjectContext, user_id, data: schemas.
             "total": 0,
             "sessions": []
         }
-    return sessions_search.search_sessions(data=data.series[0].filter, project=project, user_id=user_id)
+    return sessions.search_sessions(data=data.series[0].filter, project_id=project.project_id, user_id=user_id)
 
 
-def get_heat_map_chart(project: schemas.ProjectContext, user_id, data: schemas.CardHeatMap,
-                       include_mobs: bool = True):
+def __get_heat_map_chart(project: schemas.ProjectContext, user_id, data: schemas.CardHeatMap,
+                         include_mobs: bool = True):
     if len(data.series) == 0:
         return None
     data.series[0].filter.filters += data.series[0].filter.events
@@ -81,8 +79,8 @@ def __get_timeseries_chart(project: schemas.ProjectContext, data: schemas.CardTi
     series_charts = []
     for i, s in enumerate(data.series):
         series_charts.append(sessions.search2_series(data=s.filter, project_id=project.project_id, density=data.density,
-                                                     metric_type=data.metric_type, metric_of=data.metric_of,
-                                                     metric_value=data.metric_value))
+                                                     view_type=data.view_type, metric_type=data.metric_type,
+                                                     metric_of=data.metric_of, metric_value=data.metric_value))
 
     results = [{}] * len(series_charts[0])
     for i in range(len(results)):
@@ -153,28 +151,33 @@ def __get_table_chart(project: schemas.ProjectContext, data: schemas.CardTable,
 
 
 def get_chart(project: schemas.ProjectContext, data: schemas.CardSchema, user_id: int):
+    if data.is_predefined:
+        return custom_metrics_predefined.get_metric(key=data.metric_of,
+                                                    project_id=project.project_id,
+                                                    data=data.model_dump())
+
     supported = {
         schemas.MetricType.TIMESERIES: __get_timeseries_chart,
         schemas.MetricType.TABLE: __get_table_chart,
-        schemas.MetricType.HEAT_MAP: get_heat_map_chart,
+        schemas.MetricType.HEAT_MAP: __get_heat_map_chart,
         schemas.MetricType.FUNNEL: __get_funnel_chart,
         schemas.MetricType.PATH_ANALYSIS: __get_path_analysis_chart
     }
     return supported.get(data.metric_type, not_supported)(project=project, data=data, user_id=user_id)
 
 
-def get_sessions_by_card_id(project: schemas.ProjectContext, user_id, metric_id, data: schemas.CardSessionsSchema):
-    if not card_exists(metric_id=metric_id, project_id=project.project_id, user_id=user_id):
+def get_sessions_by_card_id(project_id, user_id, metric_id, data: schemas.CardSessionsSchema):
+    if not card_exists(metric_id=metric_id, project_id=project_id, user_id=user_id):
         return None
     results = []
     for s in data.series:
         results.append({"seriesId": s.series_id, "seriesName": s.name,
-                        **sessions_search.search_sessions(data=s.filter, project=project, user_id=user_id)})
+                        **sessions.search_sessions(data=s.filter, project_id=project_id, user_id=user_id)})
 
     return results
 
 
-def get_sessions(project: schemas.ProjectContext, user_id, data: schemas.CardSessionsSchema):
+def get_sessions(project_id, user_id, data: schemas.CardSessionsSchema):
     results = []
     if len(data.series) == 0:
         return results
@@ -184,12 +187,14 @@ def get_sessions(project: schemas.ProjectContext, user_id, data: schemas.CardSes
             s.filter = schemas.SessionsSearchPayloadSchema(**s.filter.model_dump(by_alias=True))
 
         results.append({"seriesId": None, "seriesName": s.name,
-                        **sessions_search.search_sessions(data=s.filter, project=project, user_id=user_id)})
+                        **sessions.search_sessions(data=s.filter, project_id=project_id, user_id=user_id)})
 
     return results
 
 
 def get_issues(project: schemas.ProjectContext, user_id: int, data: schemas.CardSchema):
+    if data.is_predefined:
+        return not_supported()
     if data.metric_of == schemas.MetricOfTable.ISSUES:
         return __get_table_of_issues(project=project, user_id=user_id, data=data)
     supported = {
@@ -201,16 +206,11 @@ def get_issues(project: schemas.ProjectContext, user_id: int, data: schemas.Card
     return supported.get(data.metric_type, not_supported)()
 
 
-def get_global_card_info(data: schemas.CardSchema):
-    r = {"hideExcess": data.hide_excess, "compareTo": data.compare_to, "rows": data.rows}
-    return r
-
-
-def get_path_analysis_card_info(data: schemas.CardPathAnalysis):
+def __get_path_analysis_card_info(data: schemas.CardPathAnalysis):
     r = {"start_point": [s.model_dump() for s in data.start_point],
          "start_type": data.start_type,
          "excludes": [e.model_dump() for e in data.excludes],
-         "rows": data.rows}
+         "hideExcess": data.hide_excess}
     return r
 
 
@@ -221,8 +221,8 @@ def create_card(project: schemas.ProjectContext, user_id, data: schemas.CardSche
             if data.session_id is not None:
                 session_data = {"sessionId": data.session_id}
             else:
-                session_data = get_heat_map_chart(project=project, user_id=user_id,
-                                                  data=data, include_mobs=False)
+                session_data = __get_heat_map_chart(project=project, user_id=user_id,
+                                                    data=data, include_mobs=False)
                 if session_data is not None:
                     session_data = {"sessionId": session_data["sessionId"]}
 
@@ -235,10 +235,8 @@ def create_card(project: schemas.ProjectContext, user_id, data: schemas.CardSche
         series_len = len(data.series)
         params = {"user_id": user_id, "project_id": project.project_id, **data.model_dump(), **_data,
                   "default_config": json.dumps(data.default_config.model_dump()), "card_info": None}
-        params["card_info"] = get_global_card_info(data=data)
         if data.metric_type == schemas.MetricType.PATH_ANALYSIS:
-            params["card_info"] = {**params["card_info"], **get_path_analysis_card_info(data=data)}
-        params["card_info"] = json.dumps(params["card_info"])
+            params["card_info"] = json.dumps(__get_path_analysis_card_info(data=data))
 
         query = """INSERT INTO metrics (project_id, user_id, name, is_public,
                             view_type, metric_type, metric_of, metric_value,
@@ -298,18 +296,16 @@ def update_card(metric_id, user_id, project_id, data: schemas.CardSchema):
         if i not in u_series_ids:
             d_series_ids.append(i)
     params["d_series_ids"] = tuple(d_series_ids)
+    params["card_info"] = None
     params["session_data"] = json.dumps(metric["data"])
-    params["card_info"] = get_global_card_info(data=data)
     if data.metric_type == schemas.MetricType.PATH_ANALYSIS:
-        params["card_info"] = {**params["card_info"], **get_path_analysis_card_info(data=data)}
+        params["card_info"] = json.dumps(__get_path_analysis_card_info(data=data))
     elif data.metric_type == schemas.MetricType.HEAT_MAP:
         if data.session_id is not None:
             params["session_data"] = json.dumps({"sessionId": data.session_id})
         elif metric.get("data") and metric["data"].get("sessionId"):
             params["session_data"] = json.dumps({"sessionId": metric["data"]["sessionId"]})
 
-    params["card_info"] = json.dumps(params["card_info"])
-
     with pg_client.PostgresClient() as cur:
         sub_queries = []
         if len(n_series) > 0:
@@ -352,100 +348,6 @@ def update_card(metric_id, user_id, project_id, data: schemas.CardSchema):
     return get_card(metric_id=metric_id, project_id=project_id, user_id=user_id)
 
 
-def search_metrics(project_id, user_id, data: schemas.MetricSearchSchema, include_series=False):
-    constraints = ["metrics.project_id = %(project_id)s", "metrics.deleted_at ISNULL"]
-    params = {
-        "project_id": project_id,
-        "user_id": user_id,
-        "offset": (data.page - 1) * data.limit,
-        "limit": data.limit,
-    }
-    if data.mine_only:
-        constraints.append("user_id = %(user_id)s")
-    else:
-        constraints.append("(user_id = %(user_id)s OR metrics.is_public)")
-    if data.shared_only:
-        constraints.append("is_public")
-
-    if data.filter is not None:
-        if data.filter.type:
-            constraints.append("metrics.metric_type = %(filter_type)s")
-            params["filter_type"] = data.filter.type
-        if data.filter.query and len(data.filter.query) > 0:
-            constraints.append("(metrics.name ILIKE %(filter_query)s OR owner.owner_name ILIKE %(filter_query)s)")
-            params["filter_query"] = helper.values_for_operator(
-                value=data.filter.query, op=schemas.SearchEventOperator.CONTAINS
-            )
-
-    with pg_client.PostgresClient() as cur:
-        sub_join = ""
-        if include_series:
-            sub_join = """LEFT JOIN LATERAL (
-                            SELECT COALESCE(jsonb_agg(metric_series.* ORDER BY index),'[]'::jsonb) AS series
-                            FROM metric_series
-                            WHERE metric_series.metric_id = metrics.metric_id
-                              AND metric_series.deleted_at ISNULL 
-                         ) AS metric_series ON (TRUE)"""
-
-        sort_column = data.sort.field if data.sort.field is not None and len(data.sort.field) > 0 \
-            else "created_at"
-        # change ascend to asc and descend to desc
-        sort_order = data.sort.order.value if hasattr(data.sort.order, "value") else data.sort.order
-        if sort_order == "ascend":
-            sort_order = "asc"
-        elif sort_order == "descend":
-            sort_order = "desc"
-
-        query = cur.mogrify(
-            f"""SELECT count(1) OVER () AS total,metric_id, project_id, user_id, name, is_public, created_at, edited_at,
-                        metric_type, metric_of, metric_format, metric_value, view_type, is_pinned, 
-                        dashboards, owner_email, owner_name, default_config AS config, thumbnail
-                FROM metrics
-                {sub_join}
-                LEFT JOIN LATERAL (
-                    SELECT COALESCE(jsonb_agg(connected_dashboards.* ORDER BY is_public, name),'[]'::jsonb) AS dashboards
-                    FROM (
-                        SELECT DISTINCT dashboard_id, name, is_public
-                        FROM dashboards
-                        INNER JOIN dashboard_widgets USING (dashboard_id)
-                        WHERE deleted_at ISNULL
-                          AND dashboard_widgets.metric_id = metrics.metric_id
-                          AND project_id = %(project_id)s
-                          AND ((dashboards.user_id = %(user_id)s OR is_public))
-                    ) AS connected_dashboards
-                ) AS connected_dashboards ON (TRUE)
-                LEFT JOIN LATERAL (
-                    SELECT email AS owner_email, name AS owner_name
-                    FROM users
-                    WHERE deleted_at ISNULL
-                      AND users.user_id = metrics.user_id
-                ) AS owner ON (TRUE)
-                WHERE {" AND ".join(constraints)}
-                ORDER BY {sort_column} {sort_order}
-                LIMIT %(limit)s OFFSET %(offset)s;""",
-            params
-        )
-        cur.execute(query)
-        rows = cur.fetchall()
-        if len(rows) > 0:
-            total = rows[0]["total"]
-            if include_series:
-                for r in rows:
-                    r.pop("total")
-                    for s in r.get("series", []):
-                        s["filter"] = helper.old_search_payload_to_flat(s["filter"])
-            else:
-                for r in rows:
-                    r.pop("total")
-                    r["created_at"] = TimeUTC.datetime_to_timestamp(r["created_at"])
-                    r["edited_at"] = TimeUTC.datetime_to_timestamp(r["edited_at"])
-            rows = helper.list_to_camel_case(rows)
-        else:
-            total = 0
-
-    return {"total": total, "list": rows}
-
-
 def search_all(project_id, user_id, data: schemas.SearchCardsSchema, include_series=False):
     constraints = ["metrics.project_id = %(project_id)s",
                    "metrics.deleted_at ISNULL"]
@@ -538,16 +440,8 @@ def delete_card(project_id, metric_id, user_id):
     return {"state": "success"}
 
 
-def __get_global_attributes(row):
-    if row is None or row.get("cardInfo") is None:
-        return row
-    card_info = row.get("cardInfo", {})
-    row["compareTo"] = card_info["compareTo"] if card_info.get("compareTo") is not None else []
-    return row
-
-
 def __get_path_analysis_attributes(row):
-    card_info = row.get("cardInfo", {})
+    card_info = row.pop("cardInfo")
     row["excludes"] = card_info.get("excludes", [])
     row["startPoint"] = card_info.get("startPoint", [])
     row["startType"] = card_info.get("startType", "start")
@@ -600,8 +494,6 @@ def get_card(metric_id, project_id, user_id, flatten: bool = True, include_data:
         row = helper.dict_to_camel_case(row)
         if row["metricType"] == schemas.MetricType.PATH_ANALYSIS:
             row = __get_path_analysis_attributes(row=row)
-        row = __get_global_attributes(row=row)
-        row.pop("cardInfo")
     return row
 
 
@@ -685,7 +577,11 @@ def make_chart_from_card(project: schemas.ProjectContext, user_id, metric_id, da
     raw_metric["density"] = data.density
     metric: schemas.CardSchema = schemas.CardSchema(**raw_metric)
 
-    if metric.metric_type == schemas.MetricType.HEAT_MAP:
+    if metric.is_predefined:
+        return custom_metrics_predefined.get_metric(key=metric.metric_of,
+                                                    project_id=project.project_id,
+                                                    data=data.model_dump())
+    elif metric.metric_type == schemas.MetricType.HEAT_MAP:
         if raw_metric["data"] and raw_metric["data"].get("sessionId"):
             return heatmaps.get_selected_session(project_id=project.project_id,
                                                  session_id=raw_metric["data"]["sessionId"])

api/chalicelib/core/custom_metrics_predefined.py

@@ -0,0 +1,25 @@
+import logging
+from typing import Union
+
+import schemas
+from chalicelib.core import metrics
+
+logger = logging.getLogger(__name__)
+
+
+def get_metric(key: Union[schemas.MetricOfWebVitals, schemas.MetricOfErrors], project_id: int, data: dict):
+    supported = {
+        schemas.MetricOfWebVitals.COUNT_SESSIONS: metrics.get_processed_sessions,
+        schemas.MetricOfWebVitals.AVG_VISITED_PAGES: metrics.get_user_activity_avg_visited_pages,
+        schemas.MetricOfWebVitals.COUNT_REQUESTS: metrics.get_top_metrics_count_requests,
+        schemas.MetricOfErrors.IMPACTED_SESSIONS_BY_JS_ERRORS: metrics.get_impacted_sessions_by_js_errors,
+        schemas.MetricOfErrors.DOMAINS_ERRORS_4XX: metrics.get_domains_errors_4xx,
+        schemas.MetricOfErrors.DOMAINS_ERRORS_5XX: metrics.get_domains_errors_5xx,
+        schemas.MetricOfErrors.ERRORS_PER_DOMAINS: metrics.get_errors_per_domains,
+        schemas.MetricOfErrors.ERRORS_PER_TYPE: metrics.get_errors_per_type,
+        schemas.MetricOfErrors.RESOURCES_BY_PARTY: metrics.get_resources_by_party,
+        schemas.MetricOfWebVitals.COUNT_USERS: metrics.get_unique_users,
+        schemas.MetricOfWebVitals.SPEED_LOCATION: metrics.get_speed_index_location,
+    }
+
+    return supported.get(key, lambda *args: None)(project_id=project_id, **data)

api/chalicelib/core/dashboards.py

@@ -1,7 +1,7 @@
 import json
 
 import schemas
-from chalicelib.core.metrics import custom_metrics
+from chalicelib.core import custom_metrics
 from chalicelib.utils import helper
 from chalicelib.utils import pg_client
 from chalicelib.utils.TimeUTC import TimeUTC

api/chalicelib/core/errors.py

@@ -0,0 +1,602 @@
+import json
+
+import schemas
+from chalicelib.core import sourcemaps, sessions
+from chalicelib.utils import errors_helper
+from chalicelib.utils import pg_client, helper
+from chalicelib.utils.TimeUTC import TimeUTC
+from chalicelib.utils.metrics_helper import __get_step_size
+
+
+def get(error_id, family=False):
+    if family:
+        return get_batch([error_id])
+    with pg_client.PostgresClient() as cur:
+        # trying: return only 1 error, without event details
+        query = cur.mogrify(
+            # "SELECT * FROM events.errors AS e INNER JOIN public.errors AS re USING(error_id) WHERE error_id = %(error_id)s;",
+            "SELECT * FROM public.errors WHERE error_id = %(error_id)s LIMIT 1;",
+            {"error_id": error_id})
+        cur.execute(query=query)
+        result = cur.fetchone()
+        if result is not None:
+            result["stacktrace_parsed_at"] = TimeUTC.datetime_to_timestamp(result["stacktrace_parsed_at"])
+        return helper.dict_to_camel_case(result)
+
+
+def get_batch(error_ids):
+    if len(error_ids) == 0:
+        return []
+    with pg_client.PostgresClient() as cur:
+        query = cur.mogrify(
+            """
+            WITH RECURSIVE error_family AS (
+                SELECT *
+                FROM public.errors
+                WHERE error_id IN %(error_ids)s
+                UNION
+                SELECT child_errors.*
+                FROM public.errors AS child_errors
+                         INNER JOIN error_family ON error_family.error_id = child_errors.parent_error_id OR error_family.parent_error_id = child_errors.error_id
+            )
+            SELECT *
+            FROM error_family;""",
+            {"error_ids": tuple(error_ids)})
+        cur.execute(query=query)
+        errors = cur.fetchall()
+        for e in errors:
+            e["stacktrace_parsed_at"] = TimeUTC.datetime_to_timestamp(e["stacktrace_parsed_at"])
+        return helper.list_to_camel_case(errors)
+
+
+def __flatten_sort_key_count_version(data, merge_nested=False):
+    if data is None:
+        return []
+    return sorted(
+        [
+            {
+                "name": f'{o["name"]}@{v["version"]}',
+                "count": v["count"]
+            } for o in data for v in o["partition"]
+        ],
+        key=lambda o: o["count"], reverse=True) if merge_nested else \
+        [
+            {
+                "name": o["name"],
+                "count": o["count"],
+            } for o in data
+        ]
+
+
+def __process_tags(row):
+    return [
+        {"name": "browser", "partitions": __flatten_sort_key_count_version(data=row.get("browsers_partition"))},
+        {"name": "browser.ver",
+         "partitions": __flatten_sort_key_count_version(data=row.pop("browsers_partition"), merge_nested=True)},
+        {"name": "OS", "partitions": __flatten_sort_key_count_version(data=row.get("os_partition"))},
+        {"name": "OS.ver",
+         "partitions": __flatten_sort_key_count_version(data=row.pop("os_partition"), merge_nested=True)},
+        {"name": "device.family", "partitions": __flatten_sort_key_count_version(data=row.get("device_partition"))},
+        {"name": "device",
+         "partitions": __flatten_sort_key_count_version(data=row.pop("device_partition"), merge_nested=True)},
+        {"name": "country", "partitions": row.pop("country_partition")}
+    ]
+
+
+def get_details(project_id, error_id, user_id, **data):
+    pg_sub_query24 = __get_basic_constraints(time_constraint=False, chart=True, step_size_name="step_size24")
+    pg_sub_query24.append("error_id = %(error_id)s")
+    pg_sub_query30_session = __get_basic_constraints(time_constraint=True, chart=False,
+                                                     startTime_arg_name="startDate30",
+                                                     endTime_arg_name="endDate30", project_key="sessions.project_id")
+    pg_sub_query30_session.append("sessions.start_ts >= %(startDate30)s")
+    pg_sub_query30_session.append("sessions.start_ts <= %(endDate30)s")
+    pg_sub_query30_session.append("error_id = %(error_id)s")
+    pg_sub_query30_err = __get_basic_constraints(time_constraint=True, chart=False, startTime_arg_name="startDate30",
+                                                 endTime_arg_name="endDate30", project_key="errors.project_id")
+    pg_sub_query30_err.append("sessions.project_id = %(project_id)s")
+    pg_sub_query30_err.append("sessions.start_ts >= %(startDate30)s")
+    pg_sub_query30_err.append("sessions.start_ts <= %(endDate30)s")
+    pg_sub_query30_err.append("error_id = %(error_id)s")
+    pg_sub_query30_err.append("source ='js_exception'")
+    pg_sub_query30 = __get_basic_constraints(time_constraint=False, chart=True, step_size_name="step_size30")
+    pg_sub_query30.append("error_id = %(error_id)s")
+    pg_basic_query = __get_basic_constraints(time_constraint=False)
+    pg_basic_query.append("error_id = %(error_id)s")
+    with pg_client.PostgresClient() as cur:
+        data["startDate24"] = TimeUTC.now(-1)
+        data["endDate24"] = TimeUTC.now()
+        data["startDate30"] = TimeUTC.now(-30)
+        data["endDate30"] = TimeUTC.now()
+        density24 = int(data.get("density24", 24))
+        step_size24 = __get_step_size(data["startDate24"], data["endDate24"], density24, factor=1)
+        density30 = int(data.get("density30", 30))
+        step_size30 = __get_step_size(data["startDate30"], data["endDate30"], density30, factor=1)
+        params = {
+            "startDate24": data['startDate24'],
+            "endDate24": data['endDate24'],
+            "startDate30": data['startDate30'],
+            "endDate30": data['endDate30'],
+            "project_id": project_id,
+            "userId": user_id,
+            "step_size24": step_size24,
+            "step_size30": step_size30,
+            "error_id": error_id}
+
+        main_pg_query = f"""\
+        SELECT error_id,
+               name,
+               message,
+               users,
+               sessions,
+               last_occurrence,
+               first_occurrence,
+               last_session_id,
+               browsers_partition,
+               os_partition,
+               device_partition,
+               country_partition,
+               chart24,
+               chart30,
+               custom_tags
+        FROM (SELECT error_id,
+                     name,
+                     message,
+                     COUNT(DISTINCT user_id)  AS users,
+                     COUNT(DISTINCT session_id) AS sessions
+              FROM public.errors
+                       INNER JOIN events.errors AS s_errors USING (error_id)
+                       INNER JOIN public.sessions USING (session_id)
+              WHERE {" AND ".join(pg_sub_query30_err)}
+              GROUP BY error_id, name, message) AS details
+                 INNER JOIN (SELECT MAX(timestamp) AS last_occurrence,
+                                    MIN(timestamp) AS first_occurrence
+                             FROM events.errors
+                             WHERE error_id = %(error_id)s) AS time_details ON (TRUE)
+                 INNER JOIN (SELECT session_id AS last_session_id,
+                                    coalesce(custom_tags, '[]')::jsonb AS custom_tags
+                             FROM events.errors
+                             LEFT JOIN LATERAL (
+                                    SELECT jsonb_agg(jsonb_build_object(errors_tags.key, errors_tags.value)) AS custom_tags
+                                    FROM errors_tags
+                                    WHERE errors_tags.error_id = %(error_id)s
+                                      AND errors_tags.session_id = errors.session_id
+                                      AND errors_tags.message_id = errors.message_id) AS errors_tags ON (TRUE)
+                             WHERE error_id = %(error_id)s
+                             ORDER BY errors.timestamp DESC
+                             LIMIT 1) AS last_session_details ON (TRUE)
+                 INNER JOIN (SELECT jsonb_agg(browser_details) AS browsers_partition
+                             FROM (SELECT *
+                                   FROM (SELECT user_browser AS name,
+                                                COUNT(session_id) AS count
+                                         FROM events.errors
+                                                  INNER JOIN sessions USING (session_id)
+                                         WHERE {" AND ".join(pg_sub_query30_session)}
+                                         GROUP BY user_browser
+                                         ORDER BY count DESC) AS count_per_browser_query
+                                            INNER JOIN LATERAL (SELECT JSONB_AGG(version_details) AS partition
+                                                                FROM (SELECT user_browser_version AS version,
+                                                                             COUNT(session_id) AS count
+                                                                      FROM events.errors INNER JOIN public.sessions USING (session_id)
+                                                                      WHERE {" AND ".join(pg_sub_query30_session)}
+                                                                        AND sessions.user_browser = count_per_browser_query.name
+                                                                      GROUP BY user_browser_version
+                                                                      ORDER BY count DESC) AS version_details
+                                       ) AS browser_version_details ON (TRUE)) AS browser_details) AS browser_details ON (TRUE)
+                 INNER JOIN (SELECT jsonb_agg(os_details) AS os_partition
+                             FROM (SELECT *
+                                   FROM (SELECT user_os AS name,
+                                                COUNT(session_id) AS count
+                                         FROM events.errors INNER JOIN public.sessions USING (session_id)
+                                         WHERE {" AND ".join(pg_sub_query30_session)}
+                                         GROUP BY user_os
+                                         ORDER BY count DESC) AS count_per_os_details
+                                            INNER JOIN LATERAL (SELECT jsonb_agg(count_per_version_details) AS partition
+                                                                FROM (SELECT COALESCE(user_os_version,'unknown') AS version, COUNT(session_id) AS count
+                                                                      FROM events.errors INNER JOIN public.sessions USING (session_id)
+                                                                      WHERE {" AND ".join(pg_sub_query30_session)}
+                                                                        AND sessions.user_os = count_per_os_details.name
+                                                                      GROUP BY user_os_version
+                                                                      ORDER BY count DESC) AS count_per_version_details
+                                                                GROUP BY count_per_os_details.name ) AS os_version_details
+                                                       ON (TRUE)) AS os_details) AS os_details ON (TRUE)
+                 INNER JOIN (SELECT jsonb_agg(device_details) AS device_partition
+                             FROM (SELECT *
+                                   FROM (SELECT user_device_type AS name,
+                                                COUNT(session_id) AS count
+                                         FROM events.errors INNER JOIN public.sessions USING (session_id)
+                                         WHERE {" AND ".join(pg_sub_query30_session)}
+                                         GROUP BY user_device_type
+                                         ORDER BY count DESC) AS count_per_device_details
+                                            INNER JOIN LATERAL (SELECT jsonb_agg(count_per_device_v_details) AS partition
+                                                                FROM (SELECT CASE
+                                                                                 WHEN user_device = '' OR user_device ISNULL
+                                                                                     THEN 'unknown'
+                                                                                 ELSE user_device END AS version,
+                                                                             COUNT(session_id)        AS count
+                                                                      FROM events.errors INNER JOIN public.sessions USING (session_id)
+                                                                      WHERE {" AND ".join(pg_sub_query30_session)}
+                                                                        AND sessions.user_device_type = count_per_device_details.name
+                                                                      GROUP BY user_device
+                                                                      ORDER BY count DESC) AS count_per_device_v_details
+                                                                GROUP BY count_per_device_details.name ) AS device_version_details
+                                                       ON (TRUE)) AS device_details) AS device_details ON (TRUE)
+                 INNER JOIN (SELECT jsonb_agg(count_per_country_details) AS country_partition
+                             FROM (SELECT user_country AS name,
+                                          COUNT(session_id) AS count
+                                   FROM events.errors INNER JOIN public.sessions USING (session_id)
+                                   WHERE {" AND ".join(pg_sub_query30_session)}
+                                   GROUP BY user_country
+                                   ORDER BY count DESC) AS count_per_country_details) AS country_details ON (TRUE)
+                 INNER JOIN (SELECT jsonb_agg(chart_details) AS chart24
+                             FROM (SELECT generated_timestamp AS timestamp,
+                                          COUNT(session_id)   AS count
+                                   FROM generate_series(%(startDate24)s, %(endDate24)s, %(step_size24)s) AS generated_timestamp
+                                            LEFT JOIN LATERAL (SELECT DISTINCT session_id
+                                                               FROM events.errors
+                                                                        INNER JOIN public.sessions USING (session_id)
+                                                               WHERE {" AND ".join(pg_sub_query24)}
+                                       ) AS chart_details ON (TRUE)
+                                   GROUP BY generated_timestamp
+                                   ORDER BY generated_timestamp) AS chart_details) AS chart_details24 ON (TRUE)
+                 INNER JOIN (SELECT jsonb_agg(chart_details) AS chart30
+                             FROM (SELECT generated_timestamp AS timestamp,
+                                          COUNT(session_id)   AS count
+                                   FROM generate_series(%(startDate30)s, %(endDate30)s, %(step_size30)s) AS generated_timestamp
+                                            LEFT JOIN LATERAL (SELECT DISTINCT session_id
+                                                               FROM events.errors INNER JOIN public.sessions USING (session_id)
+                                                               WHERE {" AND ".join(pg_sub_query30)}) AS chart_details
+                                                      ON (TRUE)
+                                   GROUP BY timestamp
+                                   ORDER BY timestamp) AS chart_details) AS chart_details30 ON (TRUE);
+        """
+
+        # print("--------------------")
+        # print(cur.mogrify(main_pg_query, params))
+        # print("--------------------")
+        cur.execute(cur.mogrify(main_pg_query, params))
+        row = cur.fetchone()
+        if row is None:
+            return {"errors": ["error not found"]}
+        row["tags"] = __process_tags(row)
+
+        query = cur.mogrify(
+            f"""SELECT error_id, status, session_id, start_ts,
+                        parent_error_id,session_id, user_anonymous_id,
+                        user_id, user_uuid, user_browser, user_browser_version,
+                        user_os, user_os_version, user_device, payload,
+                                    FALSE AS favorite,
+                                       True AS viewed
+                                FROM public.errors AS pe
+                                         INNER JOIN events.errors AS ee USING (error_id)
+                                         INNER JOIN public.sessions USING (session_id)
+                                WHERE pe.project_id = %(project_id)s
+                                  AND error_id = %(error_id)s
+                                ORDER BY start_ts DESC
+                                LIMIT 1;""",
+            {"project_id": project_id, "error_id": error_id, "user_id": user_id})
+        cur.execute(query=query)
+        status = cur.fetchone()
+
+    if status is not None:
+        row["stack"] = errors_helper.format_first_stack_frame(status).pop("stack")
+        row["status"] = status.pop("status")
+        row["parent_error_id"] = status.pop("parent_error_id")
+        row["favorite"] = status.pop("favorite")
+        row["viewed"] = status.pop("viewed")
+        row["last_hydrated_session"] = status
+    else:
+        row["stack"] = []
+        row["last_hydrated_session"] = None
+        row["status"] = "untracked"
+        row["parent_error_id"] = None
+        row["favorite"] = False
+        row["viewed"] = False
+    return {"data": helper.dict_to_camel_case(row)}
+
+
+def __get_basic_constraints(platform=None, time_constraint=True, startTime_arg_name="startDate",
+                            endTime_arg_name="endDate", chart=False, step_size_name="step_size",
+                            project_key="project_id"):
+    if project_key is None:
+        ch_sub_query = []
+    else:
+        ch_sub_query = [f"{project_key} =%(project_id)s"]
+    if time_constraint:
+        ch_sub_query += [f"timestamp >= %({startTime_arg_name})s",
+                         f"timestamp < %({endTime_arg_name})s"]
+    if chart:
+        ch_sub_query += [f"timestamp >=  generated_timestamp",
+                         f"timestamp <  generated_timestamp + %({step_size_name})s"]
+    if platform == schemas.PlatformType.MOBILE:
+        ch_sub_query.append("user_device_type = 'mobile'")
+    elif platform == schemas.PlatformType.DESKTOP:
+        ch_sub_query.append("user_device_type = 'desktop'")
+    return ch_sub_query
+
+
+def __get_sort_key(key):
+    return {
+        schemas.ErrorSort.OCCURRENCE: "max_datetime",
+        schemas.ErrorSort.USERS_COUNT: "users",
+        schemas.ErrorSort.SESSIONS_COUNT: "sessions"
+    }.get(key, 'max_datetime')
+
+
+def search(data: schemas.SearchErrorsSchema, project_id, user_id):
+    empty_response = {
+        'total': 0,
+        'errors': []
+    }
+
+    platform = None
+    for f in data.filters:
+        if f.type == schemas.FilterType.PLATFORM and len(f.value) > 0:
+            platform = f.value[0]
+    pg_sub_query = __get_basic_constraints(platform, project_key="sessions.project_id")
+    pg_sub_query += ["sessions.start_ts>=%(startDate)s", "sessions.start_ts<%(endDate)s", "source ='js_exception'",
+                     "pe.project_id=%(project_id)s"]
+    # To ignore Script error
+    pg_sub_query.append("pe.message!='Script error.'")
+    pg_sub_query_chart = __get_basic_constraints(platform, time_constraint=False, chart=True, project_key=None)
+    if platform:
+        pg_sub_query_chart += ["start_ts>=%(startDate)s", "start_ts<%(endDate)s", "project_id=%(project_id)s"]
+    pg_sub_query_chart.append("errors.error_id =details.error_id")
+    statuses = []
+    error_ids = None
+    if data.startTimestamp is None:
+        data.startTimestamp = TimeUTC.now(-30)
+    if data.endTimestamp is None:
+        data.endTimestamp = TimeUTC.now(1)
+    if len(data.events) > 0 or len(data.filters) > 0:
+        print("-- searching for sessions before errors")
+        statuses = sessions.search_sessions(data=data, project_id=project_id, user_id=user_id, errors_only=True,
+                                            error_status=data.status)
+        if len(statuses) == 0:
+            return empty_response
+        error_ids = [e["errorId"] for e in statuses]
+    with pg_client.PostgresClient() as cur:
+        step_size = __get_step_size(data.startTimestamp, data.endTimestamp, data.density, factor=1)
+        sort = __get_sort_key('datetime')
+        if data.sort is not None:
+            sort = __get_sort_key(data.sort)
+        order = schemas.SortOrderType.DESC
+        if data.order is not None:
+            order = data.order
+        extra_join = ""
+
+        params = {
+            "startDate": data.startTimestamp,
+            "endDate": data.endTimestamp,
+            "project_id": project_id,
+            "userId": user_id,
+            "step_size": step_size}
+        if data.status != schemas.ErrorStatus.ALL:
+            pg_sub_query.append("status = %(error_status)s")
+            params["error_status"] = data.status
+        if data.limit is not None and data.page is not None:
+            params["errors_offset"] = (data.page - 1) * data.limit
+            params["errors_limit"] = data.limit
+        else:
+            params["errors_offset"] = 0
+            params["errors_limit"] = 200
+
+        if error_ids is not None:
+            params["error_ids"] = tuple(error_ids)
+            pg_sub_query.append("error_id IN %(error_ids)s")
+        # if data.bookmarked:
+        #     pg_sub_query.append("ufe.user_id = %(userId)s")
+        #     extra_join += " INNER JOIN public.user_favorite_errors AS ufe USING (error_id)"
+        if data.query is not None and len(data.query) > 0:
+            pg_sub_query.append("(pe.name ILIKE %(error_query)s OR pe.message ILIKE %(error_query)s)")
+            params["error_query"] = helper.values_for_operator(value=data.query,
+                                                               op=schemas.SearchEventOperator.CONTAINS)
+
+        main_pg_query = f"""SELECT full_count,
+                                   error_id,
+                                   name,
+                                   message,
+                                   users,
+                                   sessions,
+                                   last_occurrence,
+                                   first_occurrence,
+                                   chart
+                            FROM (SELECT COUNT(details) OVER () AS full_count, details.*
+                                    FROM (SELECT error_id,
+                                             name,
+                                             message,
+                                             COUNT(DISTINCT COALESCE(user_id,user_uuid::text))  AS users,
+                                             COUNT(DISTINCT session_id) AS sessions,
+                                             MAX(timestamp)             AS max_datetime,
+                                             MIN(timestamp)             AS min_datetime
+                                          FROM events.errors
+                                                   INNER JOIN public.errors AS pe USING (error_id)
+                                                   INNER JOIN public.sessions USING (session_id)
+                                                   {extra_join}
+                                          WHERE {" AND ".join(pg_sub_query)}
+                                          GROUP BY error_id, name, message
+                                          ORDER BY {sort} {order}) AS details
+                                    LIMIT %(errors_limit)s OFFSET %(errors_offset)s
+                                  ) AS details
+                                     INNER JOIN LATERAL (SELECT MAX(timestamp) AS last_occurrence,
+                                                                MIN(timestamp) AS first_occurrence
+                                                         FROM events.errors
+                                                         WHERE errors.error_id = details.error_id) AS time_details ON (TRUE)
+                                     INNER JOIN LATERAL (SELECT jsonb_agg(chart_details) AS chart
+                                                         FROM (SELECT generated_timestamp AS timestamp,
+                                                                      COUNT(session_id)   AS count
+                                                               FROM generate_series(%(startDate)s, %(endDate)s, %(step_size)s) AS generated_timestamp
+                                                                        LEFT JOIN LATERAL (SELECT DISTINCT session_id
+                                                                                           FROM events.errors 
+                                                                                                {"INNER JOIN public.sessions USING(session_id)" if platform else ""}
+                                                                                           WHERE {" AND ".join(pg_sub_query_chart)}
+                                                                            ) AS sessions ON (TRUE)
+                                                               GROUP BY timestamp
+                                                               ORDER BY timestamp) AS chart_details) AS chart_details ON (TRUE);"""
+
+        # print("--------------------")
+        # print(cur.mogrify(main_pg_query, params))
+        # print("--------------------")
+
+        cur.execute(cur.mogrify(main_pg_query, params))
+        rows = cur.fetchall()
+        total = 0 if len(rows) == 0 else rows[0]["full_count"]
+
+        if total == 0:
+            rows = []
+        else:
+            if len(statuses) == 0:
+                query = cur.mogrify(
+                    """SELECT error_id,
+                            COALESCE((SELECT TRUE
+                                         FROM public.user_viewed_errors AS ve
+                                         WHERE errors.error_id = ve.error_id
+                                           AND ve.user_id = %(user_id)s LIMIT 1), FALSE) AS viewed
+                        FROM public.errors 
+                        WHERE project_id = %(project_id)s AND error_id IN %(error_ids)s;""",
+                    {"project_id": project_id, "error_ids": tuple([r["error_id"] for r in rows]),
+                     "user_id": user_id})
+                cur.execute(query=query)
+                statuses = helper.list_to_camel_case(cur.fetchall())
+    statuses = {
+        s["errorId"]: s for s in statuses
+    }
+
+    for r in rows:
+        r.pop("full_count")
+        if r["error_id"] in statuses:
+            r["viewed"] = statuses[r["error_id"]]["viewed"]
+        else:
+            r["viewed"] = False
+
+    return {
+        'total': total,
+        'errors': helper.list_to_camel_case(rows)
+    }
+
+
+def __save_stacktrace(error_id, data):
+    with pg_client.PostgresClient() as cur:
+        query = cur.mogrify(
+            """UPDATE public.errors 
+                SET stacktrace=%(data)s::jsonb, stacktrace_parsed_at=timezone('utc'::text, now())
+                WHERE error_id = %(error_id)s;""",
+            {"error_id": error_id, "data": json.dumps(data)})
+        cur.execute(query=query)
+
+
+def get_trace(project_id, error_id):
+    error = get(error_id=error_id, family=False)
+    if error is None:
+        return {"errors": ["error not found"]}
+    if error.get("source", "") != "js_exception":
+        return {"errors": ["this source of errors doesn't have a sourcemap"]}
+    if error.get("payload") is None:
+        return {"errors": ["null payload"]}
+    if error.get("stacktrace") is not None:
+        return {"sourcemapUploaded": True,
+                "trace": error.get("stacktrace"),
+                "preparsed": True}
+    trace, all_exists = sourcemaps.get_traces_group(project_id=project_id, payload=error["payload"])
+    if all_exists:
+        __save_stacktrace(error_id=error_id, data=trace)
+    return {"sourcemapUploaded": all_exists,
+            "trace": trace,
+            "preparsed": False}
+
+
+def get_sessions(start_date, end_date, project_id, user_id, error_id):
+    extra_constraints = ["s.project_id = %(project_id)s",
+                         "s.start_ts >= %(startDate)s",
+                         "s.start_ts <= %(endDate)s",
+                         "e.error_id = %(error_id)s"]
+    if start_date is None:
+        start_date = TimeUTC.now(-7)
+    if end_date is None:
+        end_date = TimeUTC.now()
+
+    params = {
+        "startDate": start_date,
+        "endDate": end_date,
+        "project_id": project_id,
+        "userId": user_id,
+        "error_id": error_id}
+    with pg_client.PostgresClient() as cur:
+        query = cur.mogrify(
+            f"""SELECT s.project_id,
+                       s.session_id::text AS session_id,
+                       s.user_uuid,
+                       s.user_id,
+                       s.user_agent,
+                       s.user_os,
+                       s.user_browser,
+                       s.user_device,
+                       s.user_country,
+                       s.start_ts,
+                       s.duration,
+                       s.events_count,
+                       s.pages_count,
+                       s.errors_count,
+                       s.issue_types,
+                        COALESCE((SELECT TRUE
+                         FROM public.user_favorite_sessions AS fs
+                         WHERE s.session_id = fs.session_id
+                           AND fs.user_id = %(userId)s LIMIT 1), FALSE) AS favorite,
+                        COALESCE((SELECT TRUE
+                         FROM public.user_viewed_sessions AS fs
+                         WHERE s.session_id = fs.session_id
+                           AND fs.user_id = %(userId)s LIMIT 1), FALSE) AS viewed
+                FROM public.sessions AS s INNER JOIN events.errors AS e USING (session_id)
+                WHERE {" AND ".join(extra_constraints)}
+                ORDER BY s.start_ts DESC;""",
+            params)
+        cur.execute(query=query)
+        sessions_list = []
+        total = cur.rowcount
+        row = cur.fetchone()
+        while row is not None and len(sessions_list) < 100:
+            sessions_list.append(row)
+            row = cur.fetchone()
+
+    return {
+        'total': total,
+        'sessions': helper.list_to_camel_case(sessions_list)
+    }
+
+
+ACTION_STATE = {
+    "unsolve": 'unresolved',
+    "solve": 'resolved',
+    "ignore": 'ignored'
+}
+
+
+def change_state(project_id, user_id, error_id, action):
+    errors = get(error_id, family=True)
+    print(len(errors))
+    status = ACTION_STATE.get(action)
+    if errors is None or len(errors) == 0:
+        return {"errors": ["error not found"]}
+    if errors[0]["status"] == status:
+        return {"errors": [f"error is already {status}"]}
+
+    if errors[0]["status"] == ACTION_STATE["solve"] and status == ACTION_STATE["ignore"]:
+        return {"errors": [f"state transition not permitted {errors[0]['status']} -> {status}"]}
+
+    params = {
+        "userId": user_id,
+        "error_ids": tuple([e["errorId"] for e in errors]),
+        "status": status}
+    with pg_client.PostgresClient() as cur:
+        query = cur.mogrify(
+            """UPDATE public.errors
+                SET status = %(status)s
+                WHERE error_id IN %(error_ids)s
+                RETURNING status""",
+            params)
+        cur.execute(query=query)
+        row = cur.fetchone()
+    if row is not None:
+        for e in errors:
+            e["status"] = row["status"]
+    return {"data": errors}

api/chalicelib/core/errors/__init__.py

@@ -1,13 +0,0 @@
-import logging
-
-from decouple import config
-
-logger = logging.getLogger(__name__)
-
-from . import errors_pg as errors_legacy
-
-if config("EXP_ERRORS_SEARCH", cast=bool, default=False):
-    logger.info(">>> Using experimental error search")
-    from . import errors_ch as errors
-else:
-    from . import errors_pg as errors

api/chalicelib/core/errors/errors_ch.py

@@ -1,409 +0,0 @@
-import schemas
-from chalicelib.core import metadata
-from chalicelib.core.errors import errors_legacy
-from chalicelib.core.errors.modules import errors_helper
-from chalicelib.core.errors.modules import sessions
-from chalicelib.utils import ch_client, exp_ch_helper
-from chalicelib.utils import helper, metrics_helper
-from chalicelib.utils.TimeUTC import TimeUTC
-
-
-def _multiple_values(values, value_key="value"):
-    query_values = {}
-    if values is not None and isinstance(values, list):
-        for i in range(len(values)):
-            k = f"{value_key}_{i}"
-            query_values[k] = values[i]
-    return query_values
-
-
-def __get_sql_operator(op: schemas.SearchEventOperator):
-    return {
-        schemas.SearchEventOperator.IS: "=",
-        schemas.SearchEventOperator.IS_ANY: "IN",
-        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",
-    }.get(op, "=")
-
-
-def _isAny_opreator(op: schemas.SearchEventOperator):
-    return op in [schemas.SearchEventOperator.ON_ANY, schemas.SearchEventOperator.IS_ANY]
-
-
-def _isUndefined_operator(op: schemas.SearchEventOperator):
-    return op in [schemas.SearchEventOperator.IS_UNDEFINED]
-
-
-def __is_negation_operator(op: schemas.SearchEventOperator):
-    return op in [schemas.SearchEventOperator.IS_NOT,
-                  schemas.SearchEventOperator.NOT_ON,
-                  schemas.SearchEventOperator.NOT_CONTAINS]
-
-
-def _multiple_conditions(condition, values, value_key="value", is_not=False):
-    query = []
-    for i in range(len(values)):
-        k = f"{value_key}_{i}"
-        query.append(condition.replace(value_key, k))
-    return "(" + (" AND " if is_not else " OR ").join(query) + ")"
-
-
-def get(error_id, family=False):
-    return errors_legacy.get(error_id=error_id, family=family)
-
-
-def get_batch(error_ids):
-    return errors_legacy.get_batch(error_ids=error_ids)
-
-
-def __get_basic_constraints_events(platform=None, time_constraint=True, startTime_arg_name="startDate",
-                                   endTime_arg_name="endDate", type_condition=True, project_key="project_id",
-                                   table_name=None):
-    ch_sub_query = [f"{project_key} =toUInt16(%(project_id)s)"]
-    if table_name is not None:
-        table_name = table_name + "."
-    else:
-        table_name = ""
-    if type_condition:
-        ch_sub_query.append(f"{table_name}`$event_name`='ERROR'")
-    if time_constraint:
-        ch_sub_query += [f"{table_name}created_at >= toDateTime(%({startTime_arg_name})s/1000)",
-                         f"{table_name}created_at < toDateTime(%({endTime_arg_name})s/1000)"]
-    # if platform == schemas.PlatformType.MOBILE:
-    #     ch_sub_query.append("user_device_type = 'mobile'")
-    # elif platform == schemas.PlatformType.DESKTOP:
-    #     ch_sub_query.append("user_device_type = 'desktop'")
-    return ch_sub_query
-
-
-def __get_sort_key(key):
-    return {
-        schemas.ErrorSort.OCCURRENCE: "max_datetime",
-        schemas.ErrorSort.USERS_COUNT: "users",
-        schemas.ErrorSort.SESSIONS_COUNT: "sessions"
-    }.get(key, 'max_datetime')
-
-
-def search(data: schemas.SearchErrorsSchema, project: schemas.ProjectContext, user_id):
-    MAIN_EVENTS_TABLE = exp_ch_helper.get_main_events_table(data.startTimestamp)
-    MAIN_SESSIONS_TABLE = exp_ch_helper.get_main_sessions_table(data.startTimestamp)
-
-    platform = None
-    for f in data.filters:
-        if f.type == schemas.FilterType.PLATFORM and len(f.value) > 0:
-            platform = f.value[0]
-    ch_sessions_sub_query = errors_helper.__get_basic_constraints_ch(platform, type_condition=False)
-    # ignore platform for errors table
-    ch_sub_query = __get_basic_constraints_events(None, type_condition=True)
-    ch_sub_query.append("JSONExtractString(toString(`$properties`), 'source') = 'js_exception'")
-
-    # To ignore Script error
-    ch_sub_query.append("JSONExtractString(toString(`$properties`), 'message') != 'Script error.'")
-    error_ids = None
-
-    if data.startTimestamp is None:
-        data.startTimestamp = TimeUTC.now(-7)
-    if data.endTimestamp is None:
-        data.endTimestamp = TimeUTC.now(1)
-
-    subquery_part = ""
-    params = {}
-    if len(data.events) > 0:
-        errors_condition_count = 0
-        for i, e in enumerate(data.events):
-            if e.type == schemas.EventType.ERROR:
-                errors_condition_count += 1
-                is_any = _isAny_opreator(e.operator)
-                op = __get_sql_operator(e.operator)
-                e_k = f"e_value{i}"
-                params = {**params, **_multiple_values(e.value, value_key=e_k)}
-                if not is_any and len(e.value) > 0 and e.value[1] not in [None, "*", ""]:
-                    ch_sub_query.append(
-                        _multiple_conditions(f"(message {op} %({e_k})s OR name {op} %({e_k})s)",
-                                             e.value, value_key=e_k))
-        if len(data.events) > errors_condition_count:
-            subquery_part_args, subquery_part = sessions.search_query_parts_ch(data=data, error_status=data.status,
-                                                                               errors_only=True,
-                                                                               project_id=project.project_id,
-                                                                               user_id=user_id,
-                                                                               issue=None,
-                                                                               favorite_only=False)
-            subquery_part = f"INNER JOIN {subquery_part} USING(session_id)"
-            params = {**params, **subquery_part_args}
-    if len(data.filters) > 0:
-        meta_keys = None
-        # to reduce include a sub-query of sessions inside events query, in order to reduce the selected data
-        for i, f in enumerate(data.filters):
-            if not isinstance(f.value, list):
-                f.value = [f.value]
-            filter_type = f.type
-            f.value = helper.values_for_operator(value=f.value, op=f.operator)
-            f_k = f"f_value{i}"
-            params = {**params, f_k: f.value, **_multiple_values(f.value, value_key=f_k)}
-            op = __get_sql_operator(f.operator) \
-                if filter_type not in [schemas.FilterType.EVENTS_COUNT] else f.operator
-            is_any = _isAny_opreator(f.operator)
-            is_undefined = _isUndefined_operator(f.operator)
-            if not is_any and not is_undefined and len(f.value) == 0:
-                continue
-            is_not = False
-            if __is_negation_operator(f.operator):
-                is_not = True
-            if filter_type == schemas.FilterType.USER_BROWSER:
-                if is_any:
-                    ch_sessions_sub_query.append('isNotNull(s.user_browser)')
-                else:
-                    ch_sessions_sub_query.append(
-                        _multiple_conditions(f's.user_browser {op} %({f_k})s', f.value, is_not=is_not,
-                                             value_key=f_k))
-
-            elif filter_type in [schemas.FilterType.USER_OS, schemas.FilterType.USER_OS_MOBILE]:
-                if is_any:
-                    ch_sessions_sub_query.append('isNotNull(s.user_os)')
-                else:
-                    ch_sessions_sub_query.append(
-                        _multiple_conditions(f's.user_os {op} %({f_k})s', f.value, is_not=is_not, value_key=f_k))
-
-            elif filter_type in [schemas.FilterType.USER_DEVICE, schemas.FilterType.USER_DEVICE_MOBILE]:
-                if is_any:
-                    ch_sessions_sub_query.append('isNotNull(s.user_device)')
-                else:
-                    ch_sessions_sub_query.append(
-                        _multiple_conditions(f's.user_device {op} %({f_k})s', f.value, is_not=is_not,
-                                             value_key=f_k))
-
-            elif filter_type in [schemas.FilterType.USER_COUNTRY, schemas.FilterType.USER_COUNTRY_MOBILE]:
-                if is_any:
-                    ch_sessions_sub_query.append('isNotNull(s.user_country)')
-                else:
-                    ch_sessions_sub_query.append(
-                        _multiple_conditions(f's.user_country {op} %({f_k})s', f.value, is_not=is_not,
-                                             value_key=f_k))
-
-            elif filter_type in [schemas.FilterType.UTM_SOURCE]:
-                if is_any:
-                    ch_sessions_sub_query.append('isNotNull(s.utm_source)')
-                elif is_undefined:
-                    ch_sessions_sub_query.append('isNull(s.utm_source)')
-                else:
-                    ch_sessions_sub_query.append(
-                        _multiple_conditions(f's.utm_source {op} toString(%({f_k})s)', f.value, is_not=is_not,
-                                             value_key=f_k))
-
-            elif filter_type in [schemas.FilterType.UTM_MEDIUM]:
-                if is_any:
-                    ch_sessions_sub_query.append('isNotNull(s.utm_medium)')
-                elif is_undefined:
-                    ch_sessions_sub_query.append('isNull(s.utm_medium)')
-                else:
-                    ch_sessions_sub_query.append(
-                        _multiple_conditions(f's.utm_medium {op} toString(%({f_k})s)', f.value, is_not=is_not,
-                                             value_key=f_k))
-            elif filter_type in [schemas.FilterType.UTM_CAMPAIGN]:
-                if is_any:
-                    ch_sessions_sub_query.append('isNotNull(s.utm_campaign)')
-                elif is_undefined:
-                    ch_sessions_sub_query.append('isNull(s.utm_campaign)')
-                else:
-                    ch_sessions_sub_query.append(
-                        _multiple_conditions(f's.utm_campaign {op} toString(%({f_k})s)', f.value, is_not=is_not,
-                                             value_key=f_k))
-
-            elif filter_type == schemas.FilterType.DURATION:
-                if len(f.value) > 0 and f.value[0] is not None:
-                    ch_sessions_sub_query.append("s.duration >= %(minDuration)s")
-                    params["minDuration"] = f.value[0]
-                if len(f.value) > 1 and f.value[1] is not None and int(f.value[1]) > 0:
-                    ch_sessions_sub_query.append("s.duration <= %(maxDuration)s")
-                    params["maxDuration"] = f.value[1]
-
-            elif filter_type == schemas.FilterType.REFERRER:
-                # extra_from += f"INNER JOIN {events.EventType.LOCATION.table} AS p USING(session_id)"
-                if is_any:
-                    referrer_constraint = 'isNotNull(s.base_referrer)'
-                else:
-                    referrer_constraint = _multiple_conditions(f"s.base_referrer {op} %({f_k})s", f.value,
-                                                               is_not=is_not, value_key=f_k)
-            elif filter_type == schemas.FilterType.METADATA:
-                # get metadata list only if you need it
-                if meta_keys is None:
-                    meta_keys = metadata.get(project_id=project.project_id)
-                    meta_keys = {m["key"]: m["index"] for m in meta_keys}
-                if f.source in meta_keys.keys():
-                    if is_any:
-                        ch_sessions_sub_query.append(f"isNotNull(s.{metadata.index_to_colname(meta_keys[f.source])})")
-                    elif is_undefined:
-                        ch_sessions_sub_query.append(f"isNull(s.{metadata.index_to_colname(meta_keys[f.source])})")
-                    else:
-                        ch_sessions_sub_query.append(
-                            _multiple_conditions(
-                                f"s.{metadata.index_to_colname(meta_keys[f.source])} {op} toString(%({f_k})s)",
-                                f.value, is_not=is_not, value_key=f_k))
-
-            elif filter_type in [schemas.FilterType.USER_ID, schemas.FilterType.USER_ID_MOBILE]:
-                if is_any:
-                    ch_sessions_sub_query.append('isNotNull(s.user_id)')
-                elif is_undefined:
-                    ch_sessions_sub_query.append('isNull(s.user_id)')
-                else:
-                    ch_sessions_sub_query.append(
-                        _multiple_conditions(f"s.user_id {op} toString(%({f_k})s)", f.value, is_not=is_not,
-                                             value_key=f_k))
-            elif filter_type in [schemas.FilterType.USER_ANONYMOUS_ID,
-                                 schemas.FilterType.USER_ANONYMOUS_ID_MOBILE]:
-                if is_any:
-                    ch_sessions_sub_query.append('isNotNull(s.user_anonymous_id)')
-                elif is_undefined:
-                    ch_sessions_sub_query.append('isNull(s.user_anonymous_id)')
-                else:
-                    ch_sessions_sub_query.append(
-                        _multiple_conditions(f"s.user_anonymous_id {op} toString(%({f_k})s)", f.value,
-                                             is_not=is_not,
-                                             value_key=f_k))
-
-            elif filter_type in [schemas.FilterType.REV_ID, schemas.FilterType.REV_ID_MOBILE]:
-                if is_any:
-                    ch_sessions_sub_query.append('isNotNull(s.rev_id)')
-                elif is_undefined:
-                    ch_sessions_sub_query.append('isNull(s.rev_id)')
-                else:
-                    ch_sessions_sub_query.append(
-                        _multiple_conditions(f"s.rev_id {op} toString(%({f_k})s)", f.value, is_not=is_not,
-                                             value_key=f_k))
-
-            elif filter_type == schemas.FilterType.PLATFORM:
-                # op = __get_sql_operator(f.operator)
-                ch_sessions_sub_query.append(
-                    _multiple_conditions(f"s.user_device_type {op} %({f_k})s", f.value, is_not=is_not,
-                                         value_key=f_k))
-            # elif filter_type == schemas.FilterType.issue:
-            #     if is_any:
-            #         ch_sessions_sub_query.append("notEmpty(s.issue_types)")
-            #     else:
-            #         ch_sessions_sub_query.append(f"hasAny(s.issue_types,%({f_k})s)")
-            #         # _multiple_conditions(f"%({f_k})s {op} ANY (s.issue_types)", f.value, is_not=is_not,
-            #         #                      value_key=f_k))
-            #
-            #         if is_not:
-            #             extra_constraints[-1] = f"not({extra_constraints[-1]})"
-            #             ss_constraints[-1] = f"not({ss_constraints[-1]})"
-            elif filter_type == schemas.FilterType.EVENTS_COUNT:
-                ch_sessions_sub_query.append(
-                    _multiple_conditions(f"s.events_count {op} %({f_k})s", f.value, is_not=is_not,
-                                         value_key=f_k))
-
-    with ch_client.ClickHouseClient() as ch:
-        step_size = metrics_helper.get_step_size(data.startTimestamp, data.endTimestamp, data.density)
-        sort = __get_sort_key('datetime')
-        if data.sort is not None:
-            sort = __get_sort_key(data.sort)
-        order = "DESC"
-        if data.order is not None:
-            order = data.order
-        params = {
-            **params,
-            "startDate": data.startTimestamp,
-            "endDate": data.endTimestamp,
-            "project_id": project.project_id,
-            "userId": user_id,
-            "step_size": step_size}
-        if data.limit is not None and data.page is not None:
-            params["errors_offset"] = (data.page - 1) * data.limit
-            params["errors_limit"] = data.limit
-        else:
-            params["errors_offset"] = 0
-            params["errors_limit"] = 200
-        # if data.bookmarked:
-        #     cur.execute(cur.mogrify(f"""SELECT error_id
-        #                                FROM public.user_favorite_errors
-        #                                WHERE user_id = %(userId)s
-        #                                {"" if error_ids is None else "AND error_id IN %(error_ids)s"}""",
-        #                             {"userId": user_id, "error_ids": tuple(error_ids or [])}))
-        #     error_ids = cur.fetchall()
-        #     if len(error_ids) == 0:
-        #         return empty_response
-        #     error_ids = [e["error_id"] for e in error_ids]
-
-        if error_ids is not None:
-            params["error_ids"] = tuple(error_ids)
-            ch_sub_query.append("error_id IN %(error_ids)s")
-
-        main_ch_query = f"""\
-                SELECT details.error_id as error_id,
-                        name, message, users, total, 
-                        sessions, last_occurrence, first_occurrence, chart
-                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 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 
-                                        FROM {MAIN_SESSIONS_TABLE} AS s
-                                                {subquery_part}
-                                        WHERE {" AND ".join(ch_sessions_sub_query)}) AS sessions 
-                                                                                    ON (events.session_id = sessions.session_id)
-                      WHERE {" AND ".join(ch_sub_query)}
-                      GROUP BY error_id, name, message
-                      ORDER BY {sort} {order}
-                      LIMIT %(errors_limit)s OFFSET %(errors_offset)s) AS details 
-                        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}
-                                     WHERE project_id=%(project_id)s
-                                        AND `$event_name`='ERROR'
-                                     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 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
-                                    LEFT JOIN {MAIN_EVENTS_TABLE} ON(TRUE)
-                            WHERE {" AND ".join(ch_sub_query)}
-                                AND created_at >= toDateTime(timestamp / 1000)
-                                AND created_at < toDateTime((timestamp + %(step_size)s) / 1000)
-                            GROUP BY error_id, timestamp
-                            ORDER BY timestamp) AS sub_table
-                            GROUP BY error_id) AS chart_details ON details.error_id=chart_details.error_id;"""
-
-        # print("------------")
-        # print(ch.format(main_ch_query, params))
-        # print("------------")
-        query = ch.format(query=main_ch_query, parameters=params)
-
-        rows = ch.execute(query=query)
-        total = rows[0]["total"] if len(rows) > 0 else 0
-
-    for r in rows:
-        r["chart"] = list(r["chart"])
-        for i in range(len(r["chart"])):
-            r["chart"][i] = {"timestamp": r["chart"][i][0], "count": r["chart"][i][1]}
-
-    return {
-        'total': total,
-        'errors': helper.list_to_camel_case(rows)
-    }
-
-
-def get_trace(project_id, error_id):
-    return errors_legacy.get_trace(project_id=project_id, error_id=error_id)
-
-
-def get_sessions(start_date, end_date, project_id, user_id, error_id):
-    return errors_legacy.get_sessions(start_date=start_date,
-                                      end_date=end_date,
-                                      project_id=project_id,
-                                      user_id=user_id,
-                                      error_id=error_id)

api/chalicelib/core/errors/errors_details.py

@@ -1,248 +0,0 @@
-from chalicelib.core.errors.modules import errors_helper
-
-from chalicelib.utils import pg_client, helper
-from chalicelib.utils.TimeUTC import TimeUTC
-from chalicelib.utils.metrics_helper import get_step_size
-
-
-def __flatten_sort_key_count_version(data, merge_nested=False):
-    if data is None:
-        return []
-    return sorted(
-        [
-            {
-                "name": f'{o["name"]}@{v["version"]}',
-                "count": v["count"]
-            } for o in data for v in o["partition"]
-        ],
-        key=lambda o: o["count"], reverse=True) if merge_nested else \
-        [
-            {
-                "name": o["name"],
-                "count": o["count"],
-            } for o in data
-        ]
-
-
-def __process_tags(row):
-    return [
-        {"name": "browser", "partitions": __flatten_sort_key_count_version(data=row.get("browsers_partition"))},
-        {"name": "browser.ver",
-         "partitions": __flatten_sort_key_count_version(data=row.pop("browsers_partition"), merge_nested=True)},
-        {"name": "OS", "partitions": __flatten_sort_key_count_version(data=row.get("os_partition"))},
-        {"name": "OS.ver",
-         "partitions": __flatten_sort_key_count_version(data=row.pop("os_partition"), merge_nested=True)},
-        {"name": "device.family", "partitions": __flatten_sort_key_count_version(data=row.get("device_partition"))},
-        {"name": "device",
-         "partitions": __flatten_sort_key_count_version(data=row.pop("device_partition"), merge_nested=True)},
-        {"name": "country", "partitions": row.pop("country_partition")}
-    ]
-
-
-def get_details(project_id, error_id, user_id, **data):
-    pg_sub_query24 = errors_helper.__get_basic_constraints(time_constraint=False, chart=True,
-                                                           step_size_name="step_size24")
-    pg_sub_query24.append("error_id = %(error_id)s")
-    pg_sub_query30_session = errors_helper.__get_basic_constraints(time_constraint=True, chart=False,
-                                                                   startTime_arg_name="startDate30",
-                                                                   endTime_arg_name="endDate30",
-                                                                   project_key="sessions.project_id")
-    pg_sub_query30_session.append("sessions.start_ts >= %(startDate30)s")
-    pg_sub_query30_session.append("sessions.start_ts <= %(endDate30)s")
-    pg_sub_query30_session.append("error_id = %(error_id)s")
-    pg_sub_query30_err = errors_helper.__get_basic_constraints(time_constraint=True, chart=False,
-                                                               startTime_arg_name="startDate30",
-                                                               endTime_arg_name="endDate30",
-                                                               project_key="errors.project_id")
-    pg_sub_query30_err.append("sessions.project_id = %(project_id)s")
-    pg_sub_query30_err.append("sessions.start_ts >= %(startDate30)s")
-    pg_sub_query30_err.append("sessions.start_ts <= %(endDate30)s")
-    pg_sub_query30_err.append("error_id = %(error_id)s")
-    pg_sub_query30_err.append("source ='js_exception'")
-    pg_sub_query30 = errors_helper.__get_basic_constraints(time_constraint=False, chart=True,
-                                                           step_size_name="step_size30")
-    pg_sub_query30.append("error_id = %(error_id)s")
-    pg_basic_query = errors_helper.__get_basic_constraints(time_constraint=False)
-    pg_basic_query.append("error_id = %(error_id)s")
-    with pg_client.PostgresClient() as cur:
-        data["startDate24"] = TimeUTC.now(-1)
-        data["endDate24"] = TimeUTC.now()
-        data["startDate30"] = TimeUTC.now(-30)
-        data["endDate30"] = TimeUTC.now()
-        density24 = int(data.get("density24", 24))
-        step_size24 = get_step_size(data["startDate24"], data["endDate24"], density24, factor=1)
-        density30 = int(data.get("density30", 30))
-        step_size30 = get_step_size(data["startDate30"], data["endDate30"], density30, factor=1)
-        params = {
-            "startDate24": data['startDate24'],
-            "endDate24": data['endDate24'],
-            "startDate30": data['startDate30'],
-            "endDate30": data['endDate30'],
-            "project_id": project_id,
-            "userId": user_id,
-            "step_size24": step_size24,
-            "step_size30": step_size30,
-            "error_id": error_id}
-
-        main_pg_query = f"""\
-        SELECT error_id,
-               name,
-               message,
-               users,
-               sessions,
-               last_occurrence,
-               first_occurrence,
-               last_session_id,
-               browsers_partition,
-               os_partition,
-               device_partition,
-               country_partition,
-               chart24,
-               chart30
-        FROM (SELECT error_id,
-                     name,
-                     message,
-                     COUNT(DISTINCT user_id)  AS users,
-                     COUNT(DISTINCT session_id) AS sessions
-              FROM public.errors
-                       INNER JOIN events.errors AS s_errors USING (error_id)
-                       INNER JOIN public.sessions USING (session_id)
-              WHERE {" AND ".join(pg_sub_query30_err)}
-              GROUP BY error_id, name, message) AS details
-                 INNER JOIN (SELECT MAX(timestamp) AS last_occurrence,
-                                    MIN(timestamp) AS first_occurrence
-                             FROM events.errors
-                             WHERE error_id = %(error_id)s) AS time_details ON (TRUE)
-                 INNER JOIN (SELECT session_id AS last_session_id
-                             FROM events.errors
-                             WHERE error_id = %(error_id)s
-                             ORDER BY errors.timestamp DESC
-                             LIMIT 1) AS last_session_details ON (TRUE)
-                 INNER JOIN (SELECT jsonb_agg(browser_details) AS browsers_partition
-                             FROM (SELECT *
-                                   FROM (SELECT user_browser AS name,
-                                                COUNT(session_id) AS count
-                                         FROM events.errors
-                                                  INNER JOIN sessions USING (session_id)
-                                         WHERE {" AND ".join(pg_sub_query30_session)}
-                                         GROUP BY user_browser
-                                         ORDER BY count DESC) AS count_per_browser_query
-                                            INNER JOIN LATERAL (SELECT JSONB_AGG(version_details) AS partition
-                                                                FROM (SELECT user_browser_version AS version,
-                                                                             COUNT(session_id) AS count
-                                                                      FROM events.errors INNER JOIN public.sessions USING (session_id)
-                                                                      WHERE {" AND ".join(pg_sub_query30_session)}
-                                                                        AND sessions.user_browser = count_per_browser_query.name
-                                                                      GROUP BY user_browser_version
-                                                                      ORDER BY count DESC) AS version_details
-                                       ) AS browser_version_details ON (TRUE)) AS browser_details) AS browser_details ON (TRUE)
-                 INNER JOIN (SELECT jsonb_agg(os_details) AS os_partition
-                             FROM (SELECT *
-                                   FROM (SELECT user_os AS name,
-                                                COUNT(session_id) AS count
-                                         FROM events.errors INNER JOIN public.sessions USING (session_id)
-                                         WHERE {" AND ".join(pg_sub_query30_session)}
-                                         GROUP BY user_os
-                                         ORDER BY count DESC) AS count_per_os_details
-                                            INNER JOIN LATERAL (SELECT jsonb_agg(count_per_version_details) AS partition
-                                                                FROM (SELECT COALESCE(user_os_version,'unknown') AS version, COUNT(session_id) AS count
-                                                                      FROM events.errors INNER JOIN public.sessions USING (session_id)
-                                                                      WHERE {" AND ".join(pg_sub_query30_session)}
-                                                                        AND sessions.user_os = count_per_os_details.name
-                                                                      GROUP BY user_os_version
-                                                                      ORDER BY count DESC) AS count_per_version_details
-                                                                GROUP BY count_per_os_details.name ) AS os_version_details
-                                                       ON (TRUE)) AS os_details) AS os_details ON (TRUE)
-                 INNER JOIN (SELECT jsonb_agg(device_details) AS device_partition
-                             FROM (SELECT *
-                                   FROM (SELECT user_device_type AS name,
-                                                COUNT(session_id) AS count
-                                         FROM events.errors INNER JOIN public.sessions USING (session_id)
-                                         WHERE {" AND ".join(pg_sub_query30_session)}
-                                         GROUP BY user_device_type
-                                         ORDER BY count DESC) AS count_per_device_details
-                                            INNER JOIN LATERAL (SELECT jsonb_agg(count_per_device_v_details) AS partition
-                                                                FROM (SELECT CASE
-                                                                                 WHEN user_device = '' OR user_device ISNULL
-                                                                                     THEN 'unknown'
-                                                                                 ELSE user_device END AS version,
-                                                                             COUNT(session_id)        AS count
-                                                                      FROM events.errors INNER JOIN public.sessions USING (session_id)
-                                                                      WHERE {" AND ".join(pg_sub_query30_session)}
-                                                                        AND sessions.user_device_type = count_per_device_details.name
-                                                                      GROUP BY user_device
-                                                                      ORDER BY count DESC) AS count_per_device_v_details
-                                                                GROUP BY count_per_device_details.name ) AS device_version_details
-                                                       ON (TRUE)) AS device_details) AS device_details ON (TRUE)
-                 INNER JOIN (SELECT jsonb_agg(count_per_country_details) AS country_partition
-                             FROM (SELECT user_country AS name,
-                                          COUNT(session_id) AS count
-                                   FROM events.errors INNER JOIN public.sessions USING (session_id)
-                                   WHERE {" AND ".join(pg_sub_query30_session)}
-                                   GROUP BY user_country
-                                   ORDER BY count DESC) AS count_per_country_details) AS country_details ON (TRUE)
-                 INNER JOIN (SELECT jsonb_agg(chart_details) AS chart24
-                             FROM (SELECT generated_timestamp AS timestamp,
-                                          COUNT(session_id)   AS count
-                                   FROM generate_series(%(startDate24)s, %(endDate24)s, %(step_size24)s) AS generated_timestamp
-                                            LEFT JOIN LATERAL (SELECT DISTINCT session_id
-                                                               FROM events.errors
-                                                                        INNER JOIN public.sessions USING (session_id)
-                                                               WHERE {" AND ".join(pg_sub_query24)}
-                                       ) AS chart_details ON (TRUE)
-                                   GROUP BY generated_timestamp
-                                   ORDER BY generated_timestamp) AS chart_details) AS chart_details24 ON (TRUE)
-                 INNER JOIN (SELECT jsonb_agg(chart_details) AS chart30
-                             FROM (SELECT generated_timestamp AS timestamp,
-                                          COUNT(session_id)   AS count
-                                   FROM generate_series(%(startDate30)s, %(endDate30)s, %(step_size30)s) AS generated_timestamp
-                                            LEFT JOIN LATERAL (SELECT DISTINCT session_id
-                                                               FROM events.errors INNER JOIN public.sessions USING (session_id)
-                                                               WHERE {" AND ".join(pg_sub_query30)}) AS chart_details
-                                                      ON (TRUE)
-                                   GROUP BY timestamp
-                                   ORDER BY timestamp) AS chart_details) AS chart_details30 ON (TRUE);
-        """
-
-        # print("--------------------")
-        # print(cur.mogrify(main_pg_query, params))
-        # print("--------------------")
-        cur.execute(cur.mogrify(main_pg_query, params))
-        row = cur.fetchone()
-        if row is None:
-            return {"errors": ["error not found"]}
-        row["tags"] = __process_tags(row)
-
-        query = cur.mogrify(
-            f"""SELECT error_id, status, session_id, start_ts,
-                        parent_error_id,session_id, user_anonymous_id,
-                        user_id, user_uuid, user_browser, user_browser_version,
-                        user_os, user_os_version, user_device, payload,
-                                    FALSE AS favorite,
-                                       True AS viewed
-                                FROM public.errors AS pe
-                                         INNER JOIN events.errors AS ee USING (error_id)
-                                         INNER JOIN public.sessions USING (session_id)
-                                WHERE pe.project_id = %(project_id)s
-                                  AND error_id = %(error_id)s
-                                ORDER BY start_ts DESC
-                                LIMIT 1;""",
-            {"project_id": project_id, "error_id": error_id, "user_id": user_id})
-        cur.execute(query=query)
-        status = cur.fetchone()
-
-    if status is not None:
-        row["stack"] = errors_helper.format_first_stack_frame(status).pop("stack")
-        row["status"] = status.pop("status")
-        row["parent_error_id"] = status.pop("parent_error_id")
-        row["favorite"] = status.pop("favorite")
-        row["viewed"] = status.pop("viewed")
-        row["last_hydrated_session"] = status
-    else:
-        row["stack"] = []
-        row["last_hydrated_session"] = None
-        row["status"] = "untracked"
-        row["parent_error_id"] = None
-        row["favorite"] = False
-        row["viewed"] = False
-    return {"data": helper.dict_to_camel_case(row)}

api/chalicelib/core/errors/errors_pg.py

@@ -1,294 +0,0 @@
-import json
-from typing import List
-
-import schemas
-from chalicelib.core.errors.modules import errors_helper
-from chalicelib.core.sessions import sessions_search
-from chalicelib.core.sourcemaps import sourcemaps
-from chalicelib.utils import pg_client, helper
-from chalicelib.utils.TimeUTC import TimeUTC
-from chalicelib.utils.metrics_helper import get_step_size
-
-
-def get(error_id, family=False) -> dict | List[dict]:
-    if family:
-        return get_batch([error_id])
-    with pg_client.PostgresClient() as cur:
-        query = cur.mogrify(
-            """SELECT * 
-               FROM public.errors 
-               WHERE error_id = %(error_id)s 
-               LIMIT 1;""",
-            {"error_id": error_id})
-        cur.execute(query=query)
-        result = cur.fetchone()
-        if result is not None:
-            result["stacktrace_parsed_at"] = TimeUTC.datetime_to_timestamp(result["stacktrace_parsed_at"])
-        return helper.dict_to_camel_case(result)
-
-
-def get_batch(error_ids):
-    if len(error_ids) == 0:
-        return []
-    with pg_client.PostgresClient() as cur:
-        query = cur.mogrify(
-            """
-            WITH RECURSIVE error_family AS (
-                SELECT *
-                FROM public.errors
-                WHERE error_id IN %(error_ids)s
-                UNION
-                SELECT child_errors.*
-                FROM public.errors AS child_errors
-                         INNER JOIN error_family ON error_family.error_id = child_errors.parent_error_id OR error_family.parent_error_id = child_errors.error_id
-            )
-            SELECT *
-            FROM error_family;""",
-            {"error_ids": tuple(error_ids)})
-        cur.execute(query=query)
-        errors = cur.fetchall()
-        for e in errors:
-            e["stacktrace_parsed_at"] = TimeUTC.datetime_to_timestamp(e["stacktrace_parsed_at"])
-        return helper.list_to_camel_case(errors)
-
-
-def __get_sort_key(key):
-    return {
-        schemas.ErrorSort.OCCURRENCE: "max_datetime",
-        schemas.ErrorSort.USERS_COUNT: "users",
-        schemas.ErrorSort.SESSIONS_COUNT: "sessions"
-    }.get(key, 'max_datetime')
-
-
-def search(data: schemas.SearchErrorsSchema, project: schemas.ProjectContext, user_id):
-    empty_response = {
-        'total': 0,
-        'errors': []
-    }
-
-    platform = None
-    for f in data.filters:
-        if f.type == schemas.FilterType.PLATFORM and len(f.value) > 0:
-            platform = f.value[0]
-    pg_sub_query = errors_helper.__get_basic_constraints(platform, project_key="sessions.project_id")
-    pg_sub_query += ["sessions.start_ts>=%(startDate)s", "sessions.start_ts<%(endDate)s", "source ='js_exception'",
-                     "pe.project_id=%(project_id)s"]
-    # To ignore Script error
-    pg_sub_query.append("pe.message!='Script error.'")
-    pg_sub_query_chart = errors_helper.__get_basic_constraints(platform, time_constraint=False, chart=True,
-                                                               project_key=None)
-    if platform:
-        pg_sub_query_chart += ["start_ts>=%(startDate)s", "start_ts<%(endDate)s", "project_id=%(project_id)s"]
-    pg_sub_query_chart.append("errors.error_id =details.error_id")
-    statuses = []
-    error_ids = None
-    if data.startTimestamp is None:
-        data.startTimestamp = TimeUTC.now(-30)
-    if data.endTimestamp is None:
-        data.endTimestamp = TimeUTC.now(1)
-    if len(data.events) > 0 or len(data.filters) > 0:
-        print("-- searching for sessions before errors")
-        statuses = sessions_search.search_sessions(data=data, project=project, user_id=user_id, errors_only=True,
-                                                   error_status=data.status)
-        if len(statuses) == 0:
-            return empty_response
-        error_ids = [e["errorId"] for e in statuses]
-    with pg_client.PostgresClient() as cur:
-        step_size = get_step_size(data.startTimestamp, data.endTimestamp, data.density, factor=1)
-        sort = __get_sort_key('datetime')
-        if data.sort is not None:
-            sort = __get_sort_key(data.sort)
-        order = schemas.SortOrderType.DESC
-        if data.order is not None:
-            order = data.order
-        extra_join = ""
-
-        params = {
-            "startDate": data.startTimestamp,
-            "endDate": data.endTimestamp,
-            "project_id": project.project_id,
-            "userId": user_id,
-            "step_size": step_size}
-        if data.status != schemas.ErrorStatus.ALL:
-            pg_sub_query.append("status = %(error_status)s")
-            params["error_status"] = data.status
-        if data.limit is not None and data.page is not None:
-            params["errors_offset"] = (data.page - 1) * data.limit
-            params["errors_limit"] = data.limit
-        else:
-            params["errors_offset"] = 0
-            params["errors_limit"] = 200
-
-        if error_ids is not None:
-            params["error_ids"] = tuple(error_ids)
-            pg_sub_query.append("error_id IN %(error_ids)s")
-        # if data.bookmarked:
-        #     pg_sub_query.append("ufe.user_id = %(userId)s")
-        #     extra_join += " INNER JOIN public.user_favorite_errors AS ufe USING (error_id)"
-        if data.query is not None and len(data.query) > 0:
-            pg_sub_query.append("(pe.name ILIKE %(error_query)s OR pe.message ILIKE %(error_query)s)")
-            params["error_query"] = helper.values_for_operator(value=data.query,
-                                                               op=schemas.SearchEventOperator.CONTAINS)
-
-        main_pg_query = f"""SELECT full_count,
-                                   error_id,
-                                   name,
-                                   message,
-                                   users,
-                                   sessions,
-                                   last_occurrence,
-                                   first_occurrence,
-                                   chart
-                            FROM (SELECT COUNT(details) OVER () AS full_count, details.*
-                                    FROM (SELECT error_id,
-                                             name,
-                                             message,
-                                             COUNT(DISTINCT COALESCE(user_id,user_uuid::text))  AS users,
-                                             COUNT(DISTINCT session_id) AS sessions,
-                                             MAX(timestamp)             AS max_datetime,
-                                             MIN(timestamp)             AS min_datetime
-                                          FROM events.errors
-                                                   INNER JOIN public.errors AS pe USING (error_id)
-                                                   INNER JOIN public.sessions USING (session_id)
-                                                   {extra_join}
-                                          WHERE {" AND ".join(pg_sub_query)}
-                                          GROUP BY error_id, name, message
-                                          ORDER BY {sort} {order}) AS details
-                                    LIMIT %(errors_limit)s OFFSET %(errors_offset)s
-                                  ) AS details
-                                     INNER JOIN LATERAL (SELECT MAX(timestamp) AS last_occurrence,
-                                                                MIN(timestamp) AS first_occurrence
-                                                         FROM events.errors
-                                                         WHERE errors.error_id = details.error_id) AS time_details ON (TRUE)
-                                     INNER JOIN LATERAL (SELECT jsonb_agg(chart_details) AS chart
-                                                         FROM (SELECT generated_timestamp AS timestamp,
-                                                                      COUNT(session_id)   AS count
-                                                               FROM generate_series(%(startDate)s, %(endDate)s, %(step_size)s) AS generated_timestamp
-                                                                        LEFT JOIN LATERAL (SELECT DISTINCT session_id
-                                                                                           FROM events.errors 
-                                                                                                {"INNER JOIN public.sessions USING(session_id)" if platform else ""}
-                                                                                           WHERE {" AND ".join(pg_sub_query_chart)}
-                                                                            ) AS sessions ON (TRUE)
-                                                               GROUP BY timestamp
-                                                               ORDER BY timestamp) AS chart_details) AS chart_details ON (TRUE);"""
-
-        # print("--------------------")
-        # print(cur.mogrify(main_pg_query, params))
-        # print("--------------------")
-
-        cur.execute(cur.mogrify(main_pg_query, params))
-        rows = cur.fetchall()
-        total = 0 if len(rows) == 0 else rows[0]["full_count"]
-
-        if total == 0:
-            rows = []
-        else:
-            if len(statuses) == 0:
-                query = cur.mogrify(
-                    """SELECT error_id
-                        FROM public.errors 
-                        WHERE project_id = %(project_id)s AND error_id IN %(error_ids)s;""",
-                    {"project_id": project.project_id, "error_ids": tuple([r["error_id"] for r in rows]),
-                     "user_id": user_id})
-                cur.execute(query=query)
-                statuses = helper.list_to_camel_case(cur.fetchall())
-    statuses = {
-        s["errorId"]: s for s in statuses
-    }
-
-    for r in rows:
-        r.pop("full_count")
-
-    return {
-        'total': total,
-        'errors': helper.list_to_camel_case(rows)
-    }
-
-
-def __save_stacktrace(error_id, data):
-    with pg_client.PostgresClient() as cur:
-        query = cur.mogrify(
-            """UPDATE public.errors 
-                SET stacktrace=%(data)s::jsonb, stacktrace_parsed_at=timezone('utc'::text, now())
-                WHERE error_id = %(error_id)s;""",
-            {"error_id": error_id, "data": json.dumps(data)})
-        cur.execute(query=query)
-
-
-def get_trace(project_id, error_id):
-    error = get(error_id=error_id, family=False)
-    if error is None:
-        return {"errors": ["error not found"]}
-    if error.get("source", "") != "js_exception":
-        return {"errors": ["this source of errors doesn't have a sourcemap"]}
-    if error.get("payload") is None:
-        return {"errors": ["null payload"]}
-    if error.get("stacktrace") is not None:
-        return {"sourcemapUploaded": True,
-                "trace": error.get("stacktrace"),
-                "preparsed": True}
-    trace, all_exists = sourcemaps.get_traces_group(project_id=project_id, payload=error["payload"])
-    if all_exists:
-        __save_stacktrace(error_id=error_id, data=trace)
-    return {"sourcemapUploaded": all_exists,
-            "trace": trace,
-            "preparsed": False}
-
-
-def get_sessions(start_date, end_date, project_id, user_id, error_id):
-    extra_constraints = ["s.project_id = %(project_id)s",
-                         "s.start_ts >= %(startDate)s",
-                         "s.start_ts <= %(endDate)s",
-                         "e.error_id = %(error_id)s"]
-    if start_date is None:
-        start_date = TimeUTC.now(-7)
-    if end_date is None:
-        end_date = TimeUTC.now()
-
-    params = {
-        "startDate": start_date,
-        "endDate": end_date,
-        "project_id": project_id,
-        "userId": user_id,
-        "error_id": error_id}
-    with pg_client.PostgresClient() as cur:
-        query = cur.mogrify(
-            f"""SELECT s.project_id,
-                       s.session_id::text AS session_id,
-                       s.user_uuid,
-                       s.user_id,
-                       s.user_agent,
-                       s.user_os,
-                       s.user_browser,
-                       s.user_device,
-                       s.user_country,
-                       s.start_ts,
-                       s.duration,
-                       s.events_count,
-                       s.pages_count,
-                       s.errors_count,
-                       s.issue_types,
-                        COALESCE((SELECT TRUE
-                         FROM public.user_favorite_sessions AS fs
-                         WHERE s.session_id = fs.session_id
-                           AND fs.user_id = %(userId)s LIMIT 1), FALSE) AS favorite,
-                        COALESCE((SELECT TRUE
-                         FROM public.user_viewed_sessions AS fs
-                         WHERE s.session_id = fs.session_id
-                           AND fs.user_id = %(userId)s LIMIT 1), FALSE) AS viewed
-                FROM public.sessions AS s INNER JOIN events.errors AS e USING (session_id)
-                WHERE {" AND ".join(extra_constraints)}
-                ORDER BY s.start_ts DESC;""",
-            params)
-        cur.execute(query=query)
-        sessions_list = []
-        total = cur.rowcount
-        row = cur.fetchone()
-        while row is not None and len(sessions_list) < 100:
-            sessions_list.append(row)
-            row = cur.fetchone()
-
-    return {
-        'total': total,
-        'sessions': helper.list_to_camel_case(sessions_list)
-    }

api/chalicelib/core/errors/modules/__init__.py

@@ -1,11 +0,0 @@
-import logging
-
-from decouple import config
-
-logger = logging.getLogger(__name__)
-from . import helper as errors_helper
-
-if config("EXP_ERRORS_SEARCH", cast=bool, default=False):
-    import chalicelib.core.sessions.sessions_ch as sessions
-else:
-    import chalicelib.core.sessions.sessions_pg as sessions

api/chalicelib/core/errors/modules/helper.py

@@ -1,58 +0,0 @@
-from typing import Optional
-
-import schemas
-from chalicelib.core.sourcemaps import sourcemaps
-
-
-def __get_basic_constraints(platform: Optional[schemas.PlatformType] = None, time_constraint: bool = True,
-                            startTime_arg_name: str = "startDate", endTime_arg_name: str = "endDate",
-                            chart: bool = False, step_size_name: str = "step_size",
-                            project_key: Optional[str] = "project_id"):
-    if project_key is None:
-        ch_sub_query = []
-    else:
-        ch_sub_query = [f"{project_key} =%(project_id)s"]
-    if time_constraint:
-        ch_sub_query += [f"timestamp >= %({startTime_arg_name})s",
-                         f"timestamp < %({endTime_arg_name})s"]
-    if chart:
-        ch_sub_query += [f"timestamp >=  generated_timestamp",
-                         f"timestamp <  generated_timestamp + %({step_size_name})s"]
-    if platform == schemas.PlatformType.MOBILE:
-        ch_sub_query.append("user_device_type = 'mobile'")
-    elif platform == schemas.PlatformType.DESKTOP:
-        ch_sub_query.append("user_device_type = 'desktop'")
-    return ch_sub_query
-
-
-def __get_basic_constraints_ch(platform=None, time_constraint=True, startTime_arg_name="startDate",
-                               endTime_arg_name="endDate", type_condition=True, project_key="project_id",
-                               table_name=None):
-    ch_sub_query = [f"{project_key} =toUInt16(%(project_id)s)"]
-    if table_name is not None:
-        table_name = table_name + "."
-    else:
-        table_name = ""
-    if type_condition:
-        ch_sub_query.append(f"{table_name}`$event_name`='ERROR'")
-    if time_constraint:
-        ch_sub_query += [f"{table_name}datetime >= toDateTime(%({startTime_arg_name})s/1000)",
-                         f"{table_name}datetime < toDateTime(%({endTime_arg_name})s/1000)"]
-    if platform == schemas.PlatformType.MOBILE:
-        ch_sub_query.append("user_device_type = 'mobile'")
-    elif platform == schemas.PlatformType.DESKTOP:
-        ch_sub_query.append("user_device_type = 'desktop'")
-    return ch_sub_query
-
-
-def format_first_stack_frame(error):
-    error["stack"] = sourcemaps.format_payload(error.pop("payload"), truncate_to_first=True)
-    for s in error["stack"]:
-        for c in s.get("context", []):
-            for sci, sc in enumerate(c):
-                if isinstance(sc, str) and len(sc) > 1000:
-                    c[sci] = sc[:1000]
-        # convert bytes to string:
-        if isinstance(s["filename"], bytes):
-            s["filename"] = s["filename"].decode("utf-8")
-    return error

api/chalicelib/core/errors_favorite.py

@@ -0,0 +1,48 @@
+from chalicelib.utils import pg_client
+
+
+def add_favorite_error(project_id, user_id, error_id):
+    with pg_client.PostgresClient() as cur:
+        cur.execute(
+            cur.mogrify(f"""INSERT INTO public.user_favorite_errors(user_id, error_id) 
+                            VALUES (%(userId)s,%(error_id)s);""",
+                        {"userId": user_id, "error_id": error_id})
+        )
+    return {"errorId": error_id, "favorite": True}
+
+
+def remove_favorite_error(project_id, user_id, error_id):
+    with pg_client.PostgresClient() as cur:
+        cur.execute(
+            cur.mogrify(f"""DELETE FROM public.user_favorite_errors                          
+                            WHERE 
+                                user_id = %(userId)s
+                                AND error_id = %(error_id)s;""",
+                        {"userId": user_id, "error_id": error_id})
+        )
+    return {"errorId": error_id, "favorite": False}
+
+
+def favorite_error(project_id, user_id, error_id):
+    exists, favorite = error_exists_and_favorite(user_id=user_id, error_id=error_id)
+    if not exists:
+        return {"errors": ["cannot bookmark non-rehydrated errors"]}
+    if favorite:
+        return remove_favorite_error(project_id=project_id, user_id=user_id, error_id=error_id)
+    return add_favorite_error(project_id=project_id, user_id=user_id, error_id=error_id)
+
+
+def error_exists_and_favorite(user_id, error_id):
+    with pg_client.PostgresClient() as cur:
+        cur.execute(
+            cur.mogrify(
+                """SELECT errors.error_id AS exists, ufe.error_id AS favorite
+                    FROM public.errors
+                             LEFT JOIN (SELECT error_id FROM public.user_favorite_errors WHERE user_id = %(userId)s) AS ufe USING (error_id)
+                    WHERE error_id = %(error_id)s;""",
+                {"userId": user_id, "error_id": error_id})
+        )
+        r = cur.fetchone()
+        if r is None:
+            return False, False
+        return True, r.get("favorite") is not None

api/chalicelib/core/errors_viewed.py

@@ -0,0 +1,37 @@
+from chalicelib.utils import pg_client
+
+
+def add_viewed_error(project_id, user_id, error_id):
+    with pg_client.PostgresClient() as cur:
+        cur.execute(
+            cur.mogrify("""INSERT INTO public.user_viewed_errors(user_id, error_id) 
+                            VALUES (%(userId)s,%(error_id)s);""",
+                        {"userId": user_id, "error_id": error_id})
+        )
+
+
+def viewed_error_exists(user_id, error_id):
+    with pg_client.PostgresClient() as cur:
+        query = cur.mogrify(
+            """SELECT 
+                    errors.error_id AS hydrated,
+                    COALESCE((SELECT TRUE
+                                         FROM public.user_viewed_errors AS ve
+                                         WHERE ve.error_id = %(error_id)s
+                                           AND ve.user_id = %(userId)s LIMIT 1), FALSE) AS viewed                                                
+                FROM public.errors
+                WHERE error_id = %(error_id)s""",
+            {"userId": user_id, "error_id": error_id})
+        cur.execute(
+            query=query
+        )
+        r = cur.fetchone()
+        if r:
+            return r.get("viewed")
+    return True
+
+
+def viewed_error(project_id, user_id, error_id):
+    if viewed_error_exists(user_id=user_id, error_id=error_id):
+        return None
+    return add_viewed_error(project_id=project_id, user_id=user_id, error_id=error_id)

api/chalicelib/core/events.py

@@ -1,9 +1,8 @@
-from functools import cache
 from typing import Optional
 
 import schemas
-from chalicelib.core import issues
 from chalicelib.core.autocomplete import autocomplete
+from chalicelib.core import issues
 from chalicelib.core.sessions import sessions_metas
 from chalicelib.utils import pg_client, helper
 from chalicelib.utils.TimeUTC import TimeUTC
@@ -138,57 +137,52 @@ class EventType:
                          column=None)  # column=None because errors are searched by name or message
 
 
-@cache
-def supported_types():
-    return {
-        EventType.CLICK.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.CLICK),
-                                                 query=autocomplete.__generic_query(typename=EventType.CLICK.ui_type)),
-        EventType.INPUT.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.INPUT),
-                                                 query=autocomplete.__generic_query(typename=EventType.INPUT.ui_type)),
-        EventType.LOCATION.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.LOCATION),
+SUPPORTED_TYPES = {
+    EventType.CLICK.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.CLICK),
+                                             query=autocomplete.__generic_query(typename=EventType.CLICK.ui_type)),
+    EventType.INPUT.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.INPUT),
+                                             query=autocomplete.__generic_query(typename=EventType.INPUT.ui_type)),
+    EventType.LOCATION.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.LOCATION),
+                                                query=autocomplete.__generic_query(
+                                                    typename=EventType.LOCATION.ui_type)),
+    EventType.CUSTOM.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.CUSTOM),
+                                              query=autocomplete.__generic_query(typename=EventType.CUSTOM.ui_type)),
+    EventType.REQUEST.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.REQUEST),
+                                               query=autocomplete.__generic_query(
+                                                   typename=EventType.REQUEST.ui_type)),
+    EventType.GRAPHQL.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.GRAPHQL),
+                                               query=autocomplete.__generic_query(
+                                                   typename=EventType.GRAPHQL.ui_type)),
+    EventType.STATEACTION.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.STATEACTION),
+                                                   query=autocomplete.__generic_query(
+                                                       typename=EventType.STATEACTION.ui_type)),
+    EventType.TAG.ui_type: SupportedFilter(get=_search_tags, query=None),
+    EventType.ERROR.ui_type: SupportedFilter(get=autocomplete.__search_errors,
+                                             query=None),
+    EventType.METADATA.ui_type: SupportedFilter(get=autocomplete.__search_metadata,
+                                                query=None),
+    #     MOBILE
+    EventType.CLICK_MOBILE.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.CLICK_MOBILE),
                                                     query=autocomplete.__generic_query(
-                                                        typename=EventType.LOCATION.ui_type)),
-        EventType.CUSTOM.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.CUSTOM),
-                                                  query=autocomplete.__generic_query(
-                                                      typename=EventType.CUSTOM.ui_type)),
-        EventType.REQUEST.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.REQUEST),
+                                                        typename=EventType.CLICK_MOBILE.ui_type)),
+    EventType.SWIPE_MOBILE.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.SWIPE_MOBILE),
+                                                    query=autocomplete.__generic_query(
+                                                        typename=EventType.SWIPE_MOBILE.ui_type)),
+    EventType.INPUT_MOBILE.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.INPUT_MOBILE),
+                                                    query=autocomplete.__generic_query(
+                                                        typename=EventType.INPUT_MOBILE.ui_type)),
+    EventType.VIEW_MOBILE.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.VIEW_MOBILE),
                                                    query=autocomplete.__generic_query(
-                                                       typename=EventType.REQUEST.ui_type)),
-        EventType.GRAPHQL.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.GRAPHQL),
-                                                   query=autocomplete.__generic_query(
-                                                       typename=EventType.GRAPHQL.ui_type)),
-        EventType.STATEACTION.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.STATEACTION),
-                                                       query=autocomplete.__generic_query(
-                                                           typename=EventType.STATEACTION.ui_type)),
-        EventType.TAG.ui_type: SupportedFilter(get=_search_tags, query=None),
-        EventType.ERROR.ui_type: SupportedFilter(get=autocomplete.__search_errors,
-                                                 query=None),
-        EventType.METADATA.ui_type: SupportedFilter(get=autocomplete.__search_metadata,
+                                                       typename=EventType.VIEW_MOBILE.ui_type)),
+    EventType.CUSTOM_MOBILE.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.CUSTOM_MOBILE),
+                                                     query=autocomplete.__generic_query(
+                                                         typename=EventType.CUSTOM_MOBILE.ui_type)),
+    EventType.REQUEST_MOBILE.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.REQUEST_MOBILE),
+                                                      query=autocomplete.__generic_query(
+                                                          typename=EventType.REQUEST_MOBILE.ui_type)),
+    EventType.CRASH_MOBILE.ui_type: SupportedFilter(get=autocomplete.__search_errors_mobile,
                                                     query=None),
-        #     MOBILE
-        EventType.CLICK_MOBILE.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.CLICK_MOBILE),
-                                                        query=autocomplete.__generic_query(
-                                                            typename=EventType.CLICK_MOBILE.ui_type)),
-        EventType.SWIPE_MOBILE.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.SWIPE_MOBILE),
-                                                        query=autocomplete.__generic_query(
-                                                            typename=EventType.SWIPE_MOBILE.ui_type)),
-        EventType.INPUT_MOBILE.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.INPUT_MOBILE),
-                                                        query=autocomplete.__generic_query(
-                                                            typename=EventType.INPUT_MOBILE.ui_type)),
-        EventType.VIEW_MOBILE.ui_type: SupportedFilter(get=autocomplete.__generic_autocomplete(EventType.VIEW_MOBILE),
-                                                       query=autocomplete.__generic_query(
-                                                           typename=EventType.VIEW_MOBILE.ui_type)),
-        EventType.CUSTOM_MOBILE.ui_type: SupportedFilter(
-            get=autocomplete.__generic_autocomplete(EventType.CUSTOM_MOBILE),
-            query=autocomplete.__generic_query(
-                typename=EventType.CUSTOM_MOBILE.ui_type)),
-        EventType.REQUEST_MOBILE.ui_type: SupportedFilter(
-            get=autocomplete.__generic_autocomplete(EventType.REQUEST_MOBILE),
-            query=autocomplete.__generic_query(
-                typename=EventType.REQUEST_MOBILE.ui_type)),
-        EventType.CRASH_MOBILE.ui_type: SupportedFilter(get=autocomplete.__search_errors_mobile,
-                                                        query=None),
-    }
+}
 
 
 def get_errors_by_session_id(session_id, project_id):
@@ -208,17 +202,20 @@ def search(text, event_type, project_id, source, key):
     if not event_type:
         return {"data": autocomplete.__get_autocomplete_table(text, project_id)}
 
-    if event_type in supported_types().keys():
-        rows = supported_types()[event_type].get(project_id=project_id, value=text, key=key, source=source)
-    elif event_type + "_MOBILE" in supported_types().keys():
-        rows = supported_types()[event_type + "_MOBILE"].get(project_id=project_id, value=text, key=key, source=source)
-    elif event_type in sessions_metas.supported_types().keys():
+    if event_type in SUPPORTED_TYPES.keys():
+        rows = SUPPORTED_TYPES[event_type].get(project_id=project_id, value=text, key=key, source=source)
+        # for IOS events autocomplete
+        # if event_type + "_IOS" in SUPPORTED_TYPES.keys():
+        #     rows += SUPPORTED_TYPES[event_type + "_IOS"].get(project_id=project_id, value=text, key=key,source=source)
+    elif event_type + "_MOBILE" in SUPPORTED_TYPES.keys():
+        rows = SUPPORTED_TYPES[event_type + "_MOBILE"].get(project_id=project_id, value=text, key=key, source=source)
+    elif event_type in sessions_metas.SUPPORTED_TYPES.keys():
         return sessions_metas.search(text, event_type, project_id)
     elif event_type.endswith("_IOS") \
-            and event_type[:-len("_IOS")] in sessions_metas.supported_types().keys():
+            and event_type[:-len("_IOS")] in sessions_metas.SUPPORTED_TYPES.keys():
         return sessions_metas.search(text, event_type, project_id)
     elif event_type.endswith("_MOBILE") \
-            and event_type[:-len("_MOBILE")] in sessions_metas.supported_types().keys():
+            and event_type[:-len("_MOBILE")] in sessions_metas.SUPPORTED_TYPES.keys():
         return sessions_metas.search(text, event_type, project_id)
     else:
         return {"errors": ["unsupported event"]}

api/chalicelib/core/funnels.py

@@ -1,7 +1,7 @@
 from typing import List
 
 import schemas
-from chalicelib.core.metrics.modules import significance
+from chalicelib.core import significance
 from chalicelib.utils import helper
 from chalicelib.utils import sql_helper as sh
 

api/chalicelib/core/health.py

@@ -27,6 +27,7 @@ HEALTH_ENDPOINTS = {
     "http": app_connection_string("http-openreplay", 8888, "metrics"),
     "ingress-nginx": app_connection_string("ingress-nginx-openreplay", 80, "healthz"),
     "integrations": app_connection_string("integrations-openreplay", 8888, "metrics"),
+    "peers": app_connection_string("peers-openreplay", 8888, "health"),
     "sink": app_connection_string("sink-openreplay", 8888, "metrics"),
     "sourcemapreader": app_connection_string(
         "sourcemapreader-openreplay", 8888, "health"
@@ -38,7 +39,9 @@ HEALTH_ENDPOINTS = {
 def __check_database_pg(*_):
     fail_response = {
         "health": False,
-        "details": {"errors": ["Postgres health-check failed"]},
+        "details": {
+            "errors": ["Postgres health-check failed"]
+        }
     }
     with pg_client.PostgresClient() as cur:
         try:
@@ -60,26 +63,29 @@ def __check_database_pg(*_):
         "details": {
             # "version": server_version["server_version"],
             # "schema": schema_version["version"]
-        },
+        }
     }
 
 
 def __always_healthy(*_):
-    return {"health": True, "details": {}}
+    return {
+        "health": True,
+        "details": {}
+    }
 
 
 def __check_be_service(service_name):
     def fn(*_):
         fail_response = {
             "health": False,
-            "details": {"errors": ["server health-check failed"]},
+            "details": {
+                "errors": ["server health-check failed"]
+            }
         }
         try:
             results = requests.get(HEALTH_ENDPOINTS.get(service_name), timeout=2)
             if results.status_code != 200:
-                logger.error(
-                    f"!! issue with the {service_name}-health code:{results.status_code}"
-                )
+                logger.error(f"!! issue with the {service_name}-health code:{results.status_code}")
                 logger.error(results.text)
                 # fail_response["details"]["errors"].append(results.text)
                 return fail_response
@@ -97,7 +103,10 @@ def __check_be_service(service_name):
                 logger.error("couldn't get response")
                 # fail_response["details"]["errors"].append(str(e))
             return fail_response
-        return {"health": True, "details": {}}
+        return {
+            "health": True,
+            "details": {}
+        }
 
     return fn
 
@@ -105,7 +114,7 @@ def __check_be_service(service_name):
 def __check_redis(*_):
     fail_response = {
         "health": False,
-        "details": {"errors": ["server health-check failed"]},
+        "details": {"errors": ["server health-check failed"]}
     }
     if config("REDIS_STRING", default=None) is None:
         # fail_response["details"]["errors"].append("REDIS_STRING not defined in env-vars")
@@ -124,14 +133,16 @@ def __check_redis(*_):
         "health": True,
         "details": {
             # "version": r.execute_command('INFO')['redis_version']
-        },
+        }
     }
 
 
 def __check_SSL(*_):
     fail_response = {
         "health": False,
-        "details": {"errors": ["SSL Certificate health-check failed"]},
+        "details": {
+            "errors": ["SSL Certificate health-check failed"]
+        }
     }
     try:
         requests.get(config("SITE_URL"), verify=True, allow_redirects=True)
@@ -139,28 +150,36 @@ def __check_SSL(*_):
         logger.error("!! health failed: SSL Certificate")
         logger.exception(e)
         return fail_response
-    return {"health": True, "details": {}}
+    return {
+        "health": True,
+        "details": {}
+    }
 
 
 def __get_sessions_stats(*_):
     with pg_client.PostgresClient() as cur:
         constraints = ["projects.deleted_at IS NULL"]
-        query = cur.mogrify(
-            f"""SELECT COALESCE(SUM(sessions_count),0) AS s_c,
+        query = cur.mogrify(f"""SELECT COALESCE(SUM(sessions_count),0) AS s_c,
                                        COALESCE(SUM(events_count),0) AS e_c
                                 FROM public.projects_stats
                                      INNER JOIN public.projects USING(project_id)
-                                WHERE {" AND ".join(constraints)};"""
-        )
+                                WHERE {" AND ".join(constraints)};""")
         cur.execute(query)
         row = cur.fetchone()
-    return {"numberOfSessionsCaptured": row["s_c"], "numberOfEventCaptured": row["e_c"]}
+    return {
+        "numberOfSessionsCaptured": row["s_c"],
+        "numberOfEventCaptured": row["e_c"]
+    }
 
 
 def get_health(tenant_id=None):
     health_map = {
-        "databases": {"postgres": __check_database_pg},
-        "ingestionPipeline": {"redis": __check_redis},
+        "databases": {
+            "postgres": __check_database_pg
+        },
+        "ingestionPipeline": {
+            "redis": __check_redis
+        },
         "backendServices": {
             "alerts": __check_be_service("alerts"),
             "assets": __check_be_service("assets"),
@@ -173,12 +192,13 @@ def get_health(tenant_id=None):
             "http": __check_be_service("http"),
             "ingress-nginx": __always_healthy,
             "integrations": __check_be_service("integrations"),
+            "peers": __check_be_service("peers"),
             "sink": __check_be_service("sink"),
             "sourcemapreader": __check_be_service("sourcemapreader"),
-            "storage": __check_be_service("storage"),
+            "storage": __check_be_service("storage")
         },
         "details": __get_sessions_stats,
-        "ssl": __check_SSL,
+        "ssl": __check_SSL
     }
     return __process_health(health_map=health_map)
 
@@ -190,16 +210,10 @@ def __process_health(health_map):
             response.pop(parent_key)
         elif isinstance(health_map[parent_key], dict):
             for element_key in health_map[parent_key]:
-                if config(
-                    f"SKIP_H_{parent_key.upper()}_{element_key.upper()}",
-                    cast=bool,
-                    default=False,
-                ):
+                if config(f"SKIP_H_{parent_key.upper()}_{element_key.upper()}", cast=bool, default=False):
                     response[parent_key].pop(element_key)
                 else:
-                    response[parent_key][element_key] = health_map[parent_key][
-                        element_key
-                    ]()
+                    response[parent_key][element_key] = health_map[parent_key][element_key]()
         else:
             response[parent_key] = health_map[parent_key]()
     return response
@@ -207,8 +221,7 @@ def __process_health(health_map):
 
 def cron():
     with pg_client.PostgresClient() as cur:
-        query = cur.mogrify(
-            """SELECT projects.project_id,
+        query = cur.mogrify("""SELECT projects.project_id,
                                       projects.created_at,
                                       projects.sessions_last_check_at,
                                       projects.first_recorded_session_at,
@@ -216,8 +229,7 @@ def cron():
                                 FROM public.projects
                                      LEFT JOIN public.projects_stats USING (project_id)
                                 WHERE projects.deleted_at IS NULL
-                                ORDER BY project_id;"""
-        )
+                                ORDER BY project_id;""")
         cur.execute(query)
         rows = cur.fetchall()
         for r in rows:
@@ -238,24 +250,20 @@ def cron():
                 count_start_from = r["last_update_at"]
 
             count_start_from = TimeUTC.datetime_to_timestamp(count_start_from)
-            params = {
-                "project_id": r["project_id"],
-                "start_ts": count_start_from,
-                "end_ts": TimeUTC.now(),
-                "sessions_count": 0,
-                "events_count": 0,
-            }
+            params = {"project_id": r["project_id"],
+                      "start_ts": count_start_from,
+                      "end_ts": TimeUTC.now(),
+                      "sessions_count": 0,
+                      "events_count": 0}
 
-            query = cur.mogrify(
-                """SELECT COUNT(1) AS sessions_count,
+            query = cur.mogrify("""SELECT COUNT(1) AS sessions_count,
                                           COALESCE(SUM(events_count),0) AS events_count
                                    FROM public.sessions
                                    WHERE project_id=%(project_id)s
                                       AND start_ts>=%(start_ts)s
                                       AND start_ts<=%(end_ts)s
                                       AND duration IS NOT NULL;""",
-                params,
-            )
+                                params)
             cur.execute(query)
             row = cur.fetchone()
             if row is not None:
@@ -263,68 +271,56 @@ def cron():
                 params["events_count"] = row["events_count"]
 
             if insert:
-                query = cur.mogrify(
-                    """INSERT INTO public.projects_stats(project_id, sessions_count, events_count, last_update_at)
+                query = cur.mogrify("""INSERT INTO public.projects_stats(project_id, sessions_count, events_count, last_update_at)
                                        VALUES (%(project_id)s, %(sessions_count)s, %(events_count)s, (now() AT TIME ZONE 'utc'::text));""",
-                    params,
-                )
+                                    params)
             else:
-                query = cur.mogrify(
-                    """UPDATE public.projects_stats
+                query = cur.mogrify("""UPDATE public.projects_stats
                                        SET sessions_count=sessions_count+%(sessions_count)s,
                                            events_count=events_count+%(events_count)s,
                                            last_update_at=(now() AT TIME ZONE 'utc'::text)
                                        WHERE project_id=%(project_id)s;""",
-                    params,
-                )
+                                    params)
             cur.execute(query)
 
 
 # this cron is used to correct the sessions&events count every week
 def weekly_cron():
     with pg_client.PostgresClient(long_query=True) as cur:
-        query = cur.mogrify(
-            """SELECT project_id,
+        query = cur.mogrify("""SELECT project_id,
                                       projects_stats.last_update_at
                                FROM public.projects
                                     LEFT JOIN public.projects_stats USING (project_id)
                                WHERE projects.deleted_at IS NULL
-                               ORDER BY project_id;"""
-        )
+                               ORDER BY project_id;""")
         cur.execute(query)
         rows = cur.fetchall()
         for r in rows:
             if r["last_update_at"] is None:
                 continue
 
-            params = {
-                "project_id": r["project_id"],
-                "end_ts": TimeUTC.now(),
-                "sessions_count": 0,
-                "events_count": 0,
-            }
+            params = {"project_id": r["project_id"],
+                      "end_ts": TimeUTC.now(),
+                      "sessions_count": 0,
+                      "events_count": 0}
 
-            query = cur.mogrify(
-                """SELECT COUNT(1) AS sessions_count,
+            query = cur.mogrify("""SELECT COUNT(1) AS sessions_count,
                                           COALESCE(SUM(events_count),0) AS events_count
                                    FROM public.sessions
                                    WHERE project_id=%(project_id)s
                                       AND start_ts<=%(end_ts)s
                                       AND duration IS NOT NULL;""",
-                params,
-            )
+                                params)
             cur.execute(query)
             row = cur.fetchone()
             if row is not None:
                 params["sessions_count"] = row["sessions_count"]
                 params["events_count"] = row["events_count"]
 
-            query = cur.mogrify(
-                """UPDATE public.projects_stats
+            query = cur.mogrify("""UPDATE public.projects_stats
                                    SET sessions_count=%(sessions_count)s,
                                        events_count=%(events_count)s,
                                        last_update_at=(now() AT TIME ZONE 'utc'::text)
                                    WHERE project_id=%(project_id)s;""",
-                params,
-            )
+                                params)
             cur.execute(query)

api/chalicelib/core/issue_tracking/github.py

@@ -1,12 +1,12 @@
 import schemas
-from chalicelib.core.issue_tracking import base
-from chalicelib.core.issue_tracking.github_issue import GithubIntegrationIssue
+from chalicelib.core.issue_tracking import integration_base
+from chalicelib.core.issue_tracking.integration_github_issue import GithubIntegrationIssue
 from chalicelib.utils import pg_client, helper
 
 PROVIDER = schemas.IntegrationType.GITHUB
 
 
-class GitHubIntegration(base.BaseIntegration):
+class GitHubIntegration(integration_base.BaseIntegration):
 
     def __init__(self, tenant_id, user_id):
         self.__tenant_id = tenant_id

api/chalicelib/core/issue_tracking/github_issue.py

@@ -1,12 +1,12 @@
-from chalicelib.core.issue_tracking.base_issue import BaseIntegrationIssue
+from chalicelib.core.issue_tracking.integration_base_issue import BaseIntegrationIssue
 from chalicelib.utils import github_client_v3
 from chalicelib.utils.github_client_v3 import github_formatters as formatter
 
 
 class GithubIntegrationIssue(BaseIntegrationIssue):
-    def __init__(self, token):
-        self.__client = github_client_v3.githubV3Request(token)
-        super(GithubIntegrationIssue, self).__init__("GITHUB", token)
+    def __init__(self, integration_token):
+        self.__client = github_client_v3.githubV3Request(integration_token)
+        super(GithubIntegrationIssue, self).__init__("GITHUB", integration_token)
 
     def get_current_user(self):
         return formatter.user(self.__client.get("/user"))
@@ -28,9 +28,9 @@ class GithubIntegrationIssue(BaseIntegrationIssue):
 
         return meta
 
-    def create_new_assignment(self, project_id, title, description, assignee,
+    def create_new_assignment(self, integration_project_id, title, description, assignee,
                               issue_type):
-        repoId = project_id
+        repoId = integration_project_id
         assignees = [assignee]
         labels = [str(issue_type)]
 
@@ -59,11 +59,11 @@ class GithubIntegrationIssue(BaseIntegrationIssue):
     def get_by_ids(self, saved_issues):
         results = []
         for i in saved_issues:
-            results.append(self.get(project_id=i["integrationProjectId"], assignment_id=i["id"]))
+            results.append(self.get(integration_project_id=i["integrationProjectId"], assignment_id=i["id"]))
         return {"issues": results}
 
-    def get(self, project_id, assignment_id):
-        repoId = project_id
+    def get(self, integration_project_id, assignment_id):
+        repoId = integration_project_id
         issueNumber = assignment_id
         issue = self.__client.get(f"/repositories/{repoId}/issues/{issueNumber}")
         issue = formatter.issue(issue)
@@ -72,17 +72,17 @@ class GithubIntegrationIssue(BaseIntegrationIssue):
                                  self.__client.get(f"/repositories/{repoId}/issues/{issueNumber}/comments")]
         return issue
 
-    def comment(self, project_id, assignment_id, comment):
-        repoId = project_id
+    def comment(self, integration_project_id, assignment_id, comment):
+        repoId = integration_project_id
         issueNumber = assignment_id
         commentCreated = self.__client.post(f"/repositories/{repoId}/issues/{issueNumber}/comments",
                                             body={"body": comment})
         return formatter.comment(commentCreated)
 
-    def get_metas(self, project_id):
+    def get_metas(self, integration_project_id):
         current_user = self.get_current_user()
         try:
-            users = self.__client.get(f"/repositories/{project_id}/collaborators")
+            users = self.__client.get(f"/repositories/{integration_project_id}/collaborators")
         except Exception as e:
             users = []
         users = [formatter.user(u) for u in users]
@@ -92,7 +92,7 @@ class GithubIntegrationIssue(BaseIntegrationIssue):
         return {"provider": self.provider.lower(),
                 'users': users,
                 'issueTypes': [formatter.label(l) for l in
-                               self.__client.get(f"/repositories/{project_id}/labels")]
+                               self.__client.get(f"/repositories/{integration_project_id}/labels")]
                 }
 
     def get_projects(self):

api/chalicelib/core/issue_tracking/integrations_global.py

@@ -1,5 +1,5 @@
 import schemas
-from chalicelib.core.modules import TENANT_CONDITION
+from chalicelib.core.issue_tracking.modules import TENANT_CONDITION
 from chalicelib.utils import pg_client
 
 

api/chalicelib/core/issue_tracking/integrations_manager.py

@@ -1,7 +1,7 @@
-from chalicelib.core.issue_tracking import github, jira_cloud
+from chalicelib.core.issue_tracking import integration_github, integration_jira_cloud
 from chalicelib.utils import pg_client
 
-SUPPORTED_TOOLS = [github.PROVIDER, jira_cloud.PROVIDER]
+SUPPORTED_TOOLS = [integration_github.PROVIDER, integration_jira_cloud.PROVIDER]
 
 
 def get_available_integrations(user_id):
@@ -23,7 +23,7 @@ def get_available_integrations(user_id):
 
 def __get_default_integration(user_id):
     current_integrations = get_available_integrations(user_id)
-    return github.PROVIDER if current_integrations["github"] else jira_cloud.PROVIDER if \
+    return integration_github.PROVIDER if current_integrations["github"] else integration_jira_cloud.PROVIDER if \
         current_integrations["jira"] else None
 
 
@@ -35,11 +35,11 @@ def get_integration(tenant_id, user_id, tool=None, for_delete=False):
     tool = tool.upper()
     if tool not in SUPPORTED_TOOLS:
         return {"errors": [f"issue tracking tool not supported yet, available: {SUPPORTED_TOOLS}"]}, None
-    if tool == jira_cloud.PROVIDER:
-        integration = jira_cloud.JIRAIntegration(tenant_id=tenant_id, user_id=user_id)
+    if tool == integration_jira_cloud.PROVIDER:
+        integration = integration_jira_cloud.JIRAIntegration(tenant_id=tenant_id, user_id=user_id)
         if not for_delete and integration.integration is not None and not integration.integration.get("valid", True):
             return {"errors": ["JIRA: connexion issue/unauthorized"]}, integration
         return None, integration
-    elif tool == github.PROVIDER:
-        return None, github.GitHubIntegration(tenant_id=tenant_id, user_id=user_id)
+    elif tool == integration_github.PROVIDER:
+        return None, integration_github.GitHubIntegration(tenant_id=tenant_id, user_id=user_id)
     return {"errors": ["lost integration"]}, None

api/chalicelib/core/issue_tracking/jira_cloud.py

@@ -1,6 +1,6 @@
 import schemas
-from chalicelib.core.issue_tracking import base
-from chalicelib.core.issue_tracking.jira_cloud_issue import JIRACloudIntegrationIssue
+from chalicelib.core.issue_tracking import integration_base
+from chalicelib.core.issue_tracking.integration_jira_cloud_issue import JIRACloudIntegrationIssue
 from chalicelib.utils import pg_client, helper
 
 PROVIDER = schemas.IntegrationType.JIRA
@@ -10,7 +10,7 @@ def obfuscate_string(string):
     return "*" * (len(string) - 4) + string[-4:]
 
 
-class JIRAIntegration(base.BaseIntegration):
+class JIRAIntegration(integration_base.BaseIntegration):
     def __init__(self, tenant_id, user_id):
         self.__tenant_id = tenant_id
         # TODO: enable super-constructor when OAuth is done
@@ -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,9 +95,10 @@ 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})
             )
@@ -111,10 +112,9 @@ 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/issue_tracking/jira_cloud_issue.py

@@ -1,5 +1,5 @@
 from chalicelib.utils import jira_client
-from chalicelib.core.issue_tracking.base_issue import BaseIntegrationIssue
+from chalicelib.core.issue_tracking.integration_base_issue import BaseIntegrationIssue
 
 
 class JIRACloudIntegrationIssue(BaseIntegrationIssue):
@@ -9,8 +9,8 @@ class JIRACloudIntegrationIssue(BaseIntegrationIssue):
         self._client = jira_client.JiraManager(self.url, self.username, token, None)
         super(JIRACloudIntegrationIssue, self).__init__("JIRA", token)
 
-    def create_new_assignment(self, project_id, title, description, assignee, issue_type):
-        self._client.set_jira_project_id(project_id)
+    def create_new_assignment(self, integration_project_id, title, description, assignee, issue_type):
+        self._client.set_jira_project_id(integration_project_id)
         data = {
             'summary': title,
             'description': description,
@@ -28,26 +28,26 @@ class JIRACloudIntegrationIssue(BaseIntegrationIssue):
             projects_map[i["integrationProjectId"]].append(i["id"])
 
         results = []
-        for project_id in projects_map:
-            self._client.set_jira_project_id(project_id)
+        for integration_project_id in projects_map:
+            self._client.set_jira_project_id(integration_project_id)
             jql = 'labels = OpenReplay'
-            if len(projects_map[project_id]) > 0:
-                jql += f" AND ID IN ({','.join(projects_map[project_id])})"
+            if len(projects_map[integration_project_id]) > 0:
+                jql += f" AND ID IN ({','.join(projects_map[integration_project_id])})"
             issues = self._client.get_issues(jql, offset=0)
             results += issues
         return {"issues": results}
 
-    def get(self, project_id, assignment_id):
-        self._client.set_jira_project_id(project_id)
+    def get(self, integration_project_id, assignment_id):
+        self._client.set_jira_project_id(integration_project_id)
         return self._client.get_issue_v3(assignment_id)
 
-    def comment(self, project_id, assignment_id, comment):
-        self._client.set_jira_project_id(project_id)
+    def comment(self, integration_project_id, assignment_id, comment):
+        self._client.set_jira_project_id(integration_project_id)
         return self._client.add_comment_v3(assignment_id, comment)
 
-    def get_metas(self, project_id):
+    def get_metas(self, integration_project_id):
         meta = {}
-        self._client.set_jira_project_id(project_id)
+        self._client.set_jira_project_id(integration_project_id)
         meta['issueTypes'] = self._client.get_issue_types()
         meta['users'] = self._client.get_assignable_users()
         return {"provider": self.provider.lower(), **meta}

api/chalicelib/core/issue_tracking/modules/__init__.py

@@ -0,0 +1 @@
+TENANT_CONDITION = "TRUE"

api/chalicelib/core/jobs.py

@@ -1,10 +1,6 @@
-import logging
-
-from chalicelib.core.sessions import sessions_mobs, sessions_devtool
 from chalicelib.utils import pg_client, helper
 from chalicelib.utils.TimeUTC import TimeUTC
-
-logger = logging.getLogger(__name__)
+from chalicelib.core.sessions import sessions_mobs, sessions_devtool
 
 
 class Actions:
@@ -154,23 +150,23 @@ def get_scheduled_jobs():
 def execute_jobs():
     jobs = get_scheduled_jobs()
     for job in jobs:
-        logger.info(f"Executing jobId:{job['jobId']}")
+        print(f"Executing jobId:{job['jobId']}")
         try:
             if job["action"] == Actions.DELETE_USER_DATA:
                 session_ids = __get_session_ids_by_user_ids(project_id=job["projectId"],
                                                             user_ids=[job["referenceId"]])
                 if len(session_ids) > 0:
-                    logger.info(f"Deleting {len(session_ids)} sessions")
+                    print(f"Deleting {len(session_ids)} sessions")
                     __delete_sessions_by_session_ids(session_ids=session_ids)
                     __delete_session_mobs_by_session_ids(session_ids=session_ids, project_id=job["projectId"])
             else:
                 raise Exception(f"The action '{job['action']}' not supported.")
 
             job["status"] = JobStatus.COMPLETED
-            logger.info(f"Job completed {job['jobId']}")
+            print(f"Job completed {job['jobId']}")
         except Exception as e:
             job["status"] = JobStatus.FAILED
             job["errors"] = str(e)
-            logger.error(f"Job failed {job['jobId']}")
+            print(f"Job failed {job['jobId']}")
 
         update(job["jobId"], job)

api/chalicelib/core/log_tools/bugsnag.py

@@ -1,5 +1,6 @@
+from chalicelib.core import log_tools
 import requests
-from chalicelib.core.log_tools import log_tools
+
 from schemas import schemas
 
 IN_TY = "bugsnag"

api/chalicelib/core/log_tools/cloudwatch.py

@@ -1,5 +1,5 @@
 import boto3
-from chalicelib.core.log_tools import log_tools
+from chalicelib.core import log_tools
 from schemas import schemas
 
 IN_TY = "cloudwatch"

api/chalicelib/core/log_tools/datadog.py

@@ -1,4 +1,4 @@
-from chalicelib.core.log_tools import log_tools
+from chalicelib.core import log_tools
 from schemas import schemas
 
 IN_TY = "datadog"

api/chalicelib/core/log_tools/elasticsearch.py

@@ -1,7 +1,8 @@
 import logging
 
-from chalicelib.core.log_tools import log_tools
 from elasticsearch import Elasticsearch
+
+from chalicelib.core import log_tools
 from schemas import schemas
 
 logger = logging.getLogger(__name__)

api/chalicelib/core/log_tools/log_tools.py

@@ -1,7 +1,6 @@
-import json
-
-from chalicelib.core.modules import TENANT_CONDITION
 from chalicelib.utils import pg_client, helper
+import json
+from chalicelib.core.log_tools.modules import TENANT_CONDITION
 
 EXCEPT = ["jira_server", "jira_cloud"]
 

api/chalicelib/core/log_tools/modules/__init__.py

@@ -0,0 +1 @@
+TENANT_CONDITION = "TRUE"

api/chalicelib/core/log_tools/newrelic.py

@@ -1,4 +1,4 @@
-from chalicelib.core.log_tools import log_tools
+from chalicelib.core import log_tools
 from schemas import schemas
 
 IN_TY = "newrelic"

api/chalicelib/core/log_tools/rollbar.py

@@ -1,4 +1,4 @@
-from chalicelib.core.log_tools import log_tools
+from chalicelib.core import log_tools
 from schemas import schemas
 
 IN_TY = "rollbar"

api/chalicelib/core/log_tools/sentry.py

@@ -1,5 +1,5 @@
 import requests
-from chalicelib.core.log_tools import log_tools
+from chalicelib.core import log_tools
 from schemas import schemas
 
 IN_TY = "sentry"

api/chalicelib/core/log_tools/stackdriver.py

@@ -1,4 +1,4 @@
-from chalicelib.core.log_tools import log_tools
+from chalicelib.core import log_tools
 from schemas import schemas
 
 IN_TY = "stackdriver"

api/chalicelib/core/log_tools/sumologic.py

@@ -1,4 +1,4 @@
-from chalicelib.core.log_tools import log_tools
+from chalicelib.core import log_tools
 from schemas import schemas
 
 IN_TY = "sumologic"

api/chalicelib/core/metadata.py

@@ -98,23 +98,17 @@ def __edit(project_id, col_index, colname, new_name):
     if col_index not in list(old_metas.keys()):
         return {"errors": ["custom field not found"]}
 
-    if old_metas[col_index]["key"] != new_name:
-        with pg_client.PostgresClient() as cur:
+    with pg_client.PostgresClient() as cur:
+        if old_metas[col_index]["key"] != new_name:
             query = cur.mogrify(f"""UPDATE public.projects 
                                     SET {colname} = %(value)s 
                                     WHERE project_id = %(project_id)s 
                                         AND deleted_at ISNULL
-                                    RETURNING {colname}, 
-                                        (SELECT {colname} FROM projects WHERE project_id = %(project_id)s) AS old_{colname};""",
+                                    RETURNING {colname};""",
                                 {"project_id": project_id, "value": new_name})
             cur.execute(query=query)
-            row = cur.fetchone()
-            new_name = row[colname]
-            old_name = row['old_' + colname]
+            new_name = cur.fetchone()[colname]
             old_metas[col_index]["key"] = new_name
-            projects.rename_metadata_condition(project_id=project_id,
-                                               old_metadata_key=old_name,
-                                               new_metadata_key=new_name)
     return {"data": old_metas[col_index]}
 
 
@@ -127,8 +121,8 @@ def edit(tenant_id, project_id, index: int, new_name: str):
 def delete(tenant_id, project_id, index: int):
     index = int(index)
     old_segments = get(project_id)
-    old_indexes = [k["index"] for k in old_segments]
-    if index not in old_indexes:
+    old_segments = [k["index"] for k in old_segments]
+    if index not in old_segments:
         return {"errors": ["custom field not found"]}
 
     with pg_client.PostgresClient() as cur:
@@ -138,8 +132,7 @@ def delete(tenant_id, project_id, index: int):
                                 WHERE project_id = %(project_id)s AND deleted_at ISNULL;""",
                             {"project_id": project_id})
         cur.execute(query=query)
-    projects.delete_metadata_condition(project_id=project_id,
-                                       metadata_key=old_segments[old_indexes.index(index)]["key"])
+
     return {"data": get(project_id)}
 
 

api/chalicelib/core/metrics.py

@@ -0,0 +1,624 @@
+import logging
+
+import schemas
+from chalicelib.core import metadata
+from chalicelib.utils import helper
+from chalicelib.utils import pg_client
+from chalicelib.utils.TimeUTC import TimeUTC
+from chalicelib.utils.metrics_helper import __get_step_size
+
+logger = logging.getLogger(__name__)
+
+
+def __get_constraints(project_id, time_constraint=True, chart=False, duration=True, project=True,
+                      project_identifier="project_id",
+                      main_table="sessions", time_column="start_ts", data={}):
+    pg_sub_query = []
+    main_table = main_table + "." if main_table is not None and len(main_table) > 0 else ""
+    if project:
+        pg_sub_query.append(f"{main_table}{project_identifier} =%({project_identifier})s")
+    if duration:
+        pg_sub_query.append(f"{main_table}duration>0")
+    if time_constraint:
+        pg_sub_query.append(f"{main_table}{time_column} >= %(startTimestamp)s")
+        pg_sub_query.append(f"{main_table}{time_column} < %(endTimestamp)s")
+    if chart:
+        pg_sub_query.append(f"{main_table}{time_column} >= generated_timestamp")
+        pg_sub_query.append(f"{main_table}{time_column} < generated_timestamp + %(step_size)s")
+    return pg_sub_query + __get_meta_constraint(project_id=project_id, data=data)
+
+
+def __merge_charts(list1, list2, time_key="timestamp"):
+    if len(list1) != len(list2):
+        raise Exception("cannot merge unequal lists")
+    result = []
+    for i in range(len(list1)):
+        timestamp = min(list1[i][time_key], list2[i][time_key])
+        result.append({**list1[i], **list2[i], time_key: timestamp})
+    return result
+
+
+def __get_constraint_values(data):
+    params = {}
+    for i, f in enumerate(data.get("filters", [])):
+        params[f"{f['key']}_{i}"] = f["value"]
+    return params
+
+
+def __get_meta_constraint(project_id, data):
+    if len(data.get("filters", [])) == 0:
+        return []
+    constraints = []
+    meta_keys = metadata.get(project_id=project_id)
+    meta_keys = {m["key"]: m["index"] for m in meta_keys}
+
+    for i, f in enumerate(data.get("filters", [])):
+        if f["key"] in meta_keys.keys():
+            key = f"sessions.metadata_{meta_keys[f['key']]})"
+            if f["value"] in ["*", ""]:
+                constraints.append(f"{key} IS NOT NULL")
+            else:
+                constraints.append(f"{key} = %({f['key']}_{i})s")
+        else:
+            filter_type = f["key"].upper()
+            filter_type = [filter_type, "USER" + filter_type, filter_type[4:]]
+            if any(item in [schemas.FilterType.USER_BROWSER] \
+                   for item in filter_type):
+                constraints.append(f"sessions.user_browser = %({f['key']}_{i})s")
+            elif any(item in [schemas.FilterType.USER_OS, schemas.FilterType.USER_OS_MOBILE] \
+                     for item in filter_type):
+                constraints.append(f"sessions.user_os = %({f['key']}_{i})s")
+            elif any(item in [schemas.FilterType.USER_DEVICE, schemas.FilterType.USER_DEVICE_MOBILE] \
+                     for item in filter_type):
+                constraints.append(f"sessions.user_device = %({f['key']}_{i})s")
+            elif any(item in [schemas.FilterType.USER_COUNTRY, schemas.FilterType.USER_COUNTRY_MOBILE] \
+                     for item in filter_type):
+                constraints.append(f"sessions.user_country  = %({f['key']}_{i})s")
+            elif any(item in [schemas.FilterType.USER_ID, schemas.FilterType.USER_ID_MOBILE] \
+                     for item in filter_type):
+                constraints.append(f"sessions.user_id = %({f['key']}_{i})s")
+            elif any(item in [schemas.FilterType.USER_ANONYMOUS_ID, schemas.FilterType.USER_ANONYMOUS_ID_MOBILE] \
+                     for item in filter_type):
+                constraints.append(f"sessions.user_anonymous_id = %({f['key']}_{i})s")
+            elif any(item in [schemas.FilterType.REV_ID, schemas.FilterType.REV_ID_MOBILE] \
+                     for item in filter_type):
+                constraints.append(f"sessions.rev_id = %({f['key']}_{i})s")
+    return constraints
+
+
+def get_processed_sessions(project_id, startTimestamp=TimeUTC.now(delta_days=-1),
+                           endTimestamp=TimeUTC.now(),
+                           density=7, **args):
+    step_size = __get_step_size(startTimestamp, endTimestamp, density, factor=1)
+    pg_sub_query = __get_constraints(project_id=project_id, data=args)
+    pg_sub_query_chart = __get_constraints(project_id=project_id, time_constraint=True,
+                                           chart=True, data=args)
+    with pg_client.PostgresClient() as cur:
+        pg_query = f"""SELECT generated_timestamp AS timestamp,
+                               COALESCE(COUNT(sessions), 0) AS value
+                        FROM generate_series(%(startTimestamp)s, %(endTimestamp)s, %(step_size)s) AS generated_timestamp
+                             LEFT JOIN LATERAL ( SELECT 1
+                                                 FROM public.sessions
+                                                 WHERE {" AND ".join(pg_sub_query_chart)}
+                             ) AS sessions ON (TRUE)
+                        GROUP BY generated_timestamp
+                        ORDER BY generated_timestamp;"""
+        params = {"step_size": step_size, "project_id": project_id, "startTimestamp": startTimestamp,
+                  "endTimestamp": endTimestamp, **__get_constraint_values(args)}
+        cur.execute(cur.mogrify(pg_query, params))
+        rows = cur.fetchall()
+        results = {
+            "value": sum([r["value"] for r in rows]),
+            "chart": rows
+        }
+
+        diff = endTimestamp - startTimestamp
+        endTimestamp = startTimestamp
+        startTimestamp = endTimestamp - diff
+
+        pg_query = f"""SELECT COUNT(sessions.session_id) AS count
+                        FROM public.sessions
+                        WHERE {" AND ".join(pg_sub_query)};"""
+        params = {"project_id": project_id, "startTimestamp": startTimestamp, "endTimestamp": endTimestamp,
+                  **__get_constraint_values(args)}
+
+        cur.execute(cur.mogrify(pg_query, params))
+
+        count = cur.fetchone()["count"]
+
+        results["progress"] = helper.__progress(old_val=count, new_val=results["value"])
+    results["unit"] = schemas.TemplatePredefinedUnits.COUNT
+    return results
+
+
+def __get_neutral(rows, add_All_if_empty=True):
+    neutral = {l: 0 for l in [i for k in [list(v.keys()) for v in rows] for i in k]}
+    if add_All_if_empty and len(neutral.keys()) <= 1:
+        neutral = {"All": 0}
+    return neutral
+
+
+def __merge_rows_with_neutral(rows, neutral):
+    for i in range(len(rows)):
+        rows[i] = {**neutral, **rows[i]}
+    return rows
+
+
+def __get_domains_errors_4xx_and_5xx(status, project_id, startTimestamp=TimeUTC.now(delta_days=-1),
+                                     endTimestamp=TimeUTC.now(), density=6, **args):
+    step_size = __get_step_size(startTimestamp, endTimestamp, density, factor=1)
+    pg_sub_query_subset = __get_constraints(project_id=project_id, time_constraint=True, chart=False, data=args)
+    pg_sub_query_chart = __get_constraints(project_id=project_id, time_constraint=False, chart=True,
+                                           data=args, main_table="requests", time_column="timestamp", project=False,
+                                           duration=False)
+    pg_sub_query_subset.append("requests.status_code/100 = %(status_code)s")
+
+    with pg_client.PostgresClient() as cur:
+        pg_query = f"""WITH requests AS (SELECT host, timestamp 
+                                         FROM events_common.requests INNER JOIN public.sessions USING (session_id)
+                                         WHERE {" AND ".join(pg_sub_query_subset)}
+                     )
+                        SELECT generated_timestamp AS timestamp,
+                                      COALESCE(JSONB_AGG(requests) FILTER ( WHERE requests IS NOT NULL ), '[]'::JSONB) AS keys
+                                FROM generate_series(%(startTimestamp)s, %(endTimestamp)s, %(step_size)s) AS generated_timestamp
+                                LEFT JOIN LATERAL ( SELECT requests.host, COUNT(*) AS count
+                                                     FROM requests
+                                                     WHERE {" AND ".join(pg_sub_query_chart)}
+                                                     GROUP BY host
+                                                     ORDER BY count DESC
+                                                     LIMIT 5
+                                     ) AS requests ON (TRUE)
+                                GROUP BY generated_timestamp
+                                ORDER BY generated_timestamp;"""
+        params = {"project_id": project_id,
+                  "startTimestamp": startTimestamp,
+                  "endTimestamp": endTimestamp,
+                  "step_size": step_size,
+                  "status_code": status, **__get_constraint_values(args)}
+        cur.execute(cur.mogrify(pg_query, params))
+        rows = cur.fetchall()
+        rows = __nested_array_to_dict_array(rows, key="host")
+        neutral = __get_neutral(rows)
+        rows = __merge_rows_with_neutral(rows, neutral)
+
+        return rows
+
+
+def get_domains_errors_4xx(project_id, startTimestamp=TimeUTC.now(delta_days=-1),
+                           endTimestamp=TimeUTC.now(), density=6, **args):
+    return __get_domains_errors_4xx_and_5xx(status=4, project_id=project_id, startTimestamp=startTimestamp,
+                                            endTimestamp=endTimestamp, density=density, **args)
+
+
+def get_domains_errors_5xx(project_id, startTimestamp=TimeUTC.now(delta_days=-1),
+                           endTimestamp=TimeUTC.now(), density=6, **args):
+    return __get_domains_errors_4xx_and_5xx(status=5, project_id=project_id, startTimestamp=startTimestamp,
+                                            endTimestamp=endTimestamp, density=density, **args)
+
+
+def __nested_array_to_dict_array(rows, key="url_host", value="count"):
+    for r in rows:
+        for i in range(len(r["keys"])):
+            r[r["keys"][i][key]] = r["keys"][i][value]
+        r.pop("keys")
+    return rows
+
+
+def get_errors_per_domains(project_id, limit, page, startTimestamp=TimeUTC.now(delta_days=-1),
+                           endTimestamp=TimeUTC.now(), **args):
+    pg_sub_query = __get_constraints(project_id=project_id, data=args)
+    pg_sub_query.append("requests.success = FALSE")
+    params = {"project_id": project_id,
+              "startTimestamp": startTimestamp,
+              "endTimestamp": endTimestamp,
+              "limit_s": (page - 1) * limit,
+              "limit_e": page * limit,
+              **__get_constraint_values(args)}
+
+    with pg_client.PostgresClient() as cur:
+        pg_query = f"""SELECT COALESCE(SUM(errors_count),0)::INT AS count,
+                              COUNT(raw.domain) AS total,
+                              jsonb_agg(raw) FILTER ( WHERE rn > %(limit_s)s 
+                                                        AND rn <= %(limit_e)s ) AS values
+                        FROM (SELECT requests.host                                                 AS domain,
+                                     COUNT(requests.session_id)                                    AS errors_count,
+                                     row_number() over (ORDER BY COUNT(requests.session_id) DESC ) AS rn
+                              FROM events_common.requests
+                                       INNER JOIN sessions USING (session_id)
+                              WHERE {" AND ".join(pg_sub_query)}
+                              GROUP BY requests.host
+                              ORDER BY errors_count DESC) AS raw;"""
+        pg_query = cur.mogrify(pg_query, params)
+        logger.debug("-----------")
+        logger.debug(pg_query)
+        logger.debug("-----------")
+        cur.execute(pg_query)
+        row = cur.fetchone()
+        if row:
+            row["values"] = row["values"] or []
+            for r in row["values"]:
+                r.pop("rn")
+
+    return helper.dict_to_camel_case(row)
+
+
+def get_errors_per_type(project_id, startTimestamp=TimeUTC.now(delta_days=-1), endTimestamp=TimeUTC.now(),
+                        platform=None, density=7, **args):
+    step_size = __get_step_size(startTimestamp, endTimestamp, density, factor=1)
+
+    pg_sub_query_subset = __get_constraints(project_id=project_id, data=args)
+    pg_sub_query_subset.append("requests.timestamp>=%(startTimestamp)s")
+    pg_sub_query_subset.append("requests.timestamp<%(endTimestamp)s")
+    pg_sub_query_subset.append("requests.status_code > 200")
+
+    pg_sub_query_subset_e = __get_constraints(project_id=project_id, data=args, duration=False, main_table="m_errors",
+                                              time_constraint=False)
+    pg_sub_query_chart = __get_constraints(project_id=project_id, time_constraint=False,
+                                           chart=True, data=args, main_table="", time_column="timestamp",
+                                           project=False, duration=False)
+    pg_sub_query_subset_e.append("timestamp>=%(startTimestamp)s")
+    pg_sub_query_subset_e.append("timestamp<%(endTimestamp)s")
+
+    with pg_client.PostgresClient() as cur:
+        pg_query = f"""WITH requests AS (SELECT status_code AS status, timestamp
+                                       FROM events_common.requests
+                                                INNER JOIN public.sessions USING (session_id)
+                                       WHERE {" AND ".join(pg_sub_query_subset)}
+                            ),
+                         errors_integ AS (SELECT timestamp
+                                          FROM events.errors
+                                                   INNER JOIN public.errors AS m_errors USING (error_id)
+                                          WHERE {" AND ".join(pg_sub_query_subset_e)}
+                                            AND source != 'js_exception'
+                         ),
+                         errors_js AS (SELECT timestamp
+                                       FROM events.errors
+                                                INNER JOIN public.errors AS m_errors USING (error_id)
+                                       WHERE {" AND ".join(pg_sub_query_subset_e)}
+                                         AND source = 'js_exception'
+                         )
+                    SELECT generated_timestamp                                       AS timestamp,
+                           COALESCE(SUM(CASE WHEN status / 100 = 4 THEN 1 ELSE 0 END), 0) AS _4xx,
+                           COALESCE(SUM(CASE WHEN status / 100 = 5 THEN 1 ELSE 0 END), 0) AS _5xx,
+                           COALESCE((SELECT COUNT(*)
+                                     FROM errors_js
+                                     WHERE {" AND ".join(pg_sub_query_chart)}
+                                    ), 0)                                                 AS js,
+                           COALESCE((SELECT COUNT(*)
+                                     FROM errors_integ
+                                     WHERE {" AND ".join(pg_sub_query_chart)}
+                                    ), 0)                                                 AS integrations
+                    FROM generate_series(%(startTimestamp)s, %(endTimestamp)s, %(step_size)s) AS generated_timestamp
+                             LEFT JOIN LATERAL (SELECT status
+                                                FROM requests
+                                                WHERE {" AND ".join(pg_sub_query_chart)}
+                        ) AS errors_partition ON (TRUE)
+                    GROUP BY timestamp
+                    ORDER BY timestamp;"""
+        params = {"step_size": step_size,
+                  "project_id": project_id,
+                  "startTimestamp": startTimestamp,
+                  "endTimestamp": endTimestamp, **__get_constraint_values(args)}
+        cur.execute(cur.mogrify(pg_query, params))
+        rows = cur.fetchall()
+        rows = helper.list_to_camel_case(rows)
+    return rows
+
+
+def get_impacted_sessions_by_js_errors(project_id, startTimestamp=TimeUTC.now(delta_days=-1),
+                                       endTimestamp=TimeUTC.now(), density=7, **args):
+    step_size = __get_step_size(startTimestamp, endTimestamp, density, factor=1)
+    pg_sub_query = __get_constraints(project_id=project_id, data=args)
+    pg_sub_query_chart = __get_constraints(project_id=project_id, time_constraint=True,
+                                           chart=True, data=args)
+    pg_sub_query.append("m_errors.source = 'js_exception'")
+    pg_sub_query.append("m_errors.project_id = %(project_id)s")
+    pg_sub_query.append("errors.timestamp >= %(startTimestamp)s")
+    pg_sub_query.append("errors.timestamp <  %(endTimestamp)s")
+    pg_sub_query_chart.append("m_errors.source = 'js_exception'")
+    pg_sub_query_chart.append("m_errors.project_id = %(project_id)s")
+    pg_sub_query_chart.append("errors.timestamp >= generated_timestamp")
+    pg_sub_query_chart.append("errors.timestamp < generated_timestamp+ %(step_size)s")
+
+    pg_sub_query_subset = __get_constraints(project_id=project_id, data=args, duration=False, main_table="m_errors",
+                                            time_constraint=False)
+    pg_sub_query_chart = __get_constraints(project_id=project_id, time_constraint=False,
+                                           chart=True, data=args, main_table="errors", time_column="timestamp",
+                                           project=False, duration=False)
+    pg_sub_query_subset.append("m_errors.source = 'js_exception'")
+    pg_sub_query_subset.append("errors.timestamp>=%(startTimestamp)s")
+    pg_sub_query_subset.append("errors.timestamp<%(endTimestamp)s")
+
+    with pg_client.PostgresClient() as cur:
+        pg_query = f"""WITH errors AS (SELECT DISTINCT ON (session_id,timestamp) session_id, timestamp
+                                        FROM events.errors
+                                                 INNER JOIN public.errors AS m_errors USING (error_id)
+                                        WHERE {" AND ".join(pg_sub_query_subset)}
+                        )
+                        SELECT *
+                        FROM (SELECT COUNT(DISTINCT session_id) AS sessions_count
+                              FROM errors) AS counts
+                                 LEFT JOIN
+                             (SELECT jsonb_agg(chart) AS chart
+                              FROM (SELECT generated_timestamp            AS timestamp,
+                                           COALESCE(COUNT(session_id), 0) AS sessions_count
+                                    FROM generate_series(%(startTimestamp)s, %(endTimestamp)s, %(step_size)s) AS generated_timestamp
+                                             LEFT JOIN LATERAL ( SELECT DISTINCT session_id
+                                                                 FROM errors
+                                                                 WHERE {" AND ".join(pg_sub_query_chart)}
+                                        ) AS sessions ON (TRUE)
+                                    GROUP BY generated_timestamp
+                                    ORDER BY generated_timestamp) AS chart) AS chart ON (TRUE);"""
+        cur.execute(cur.mogrify(pg_query, {"step_size": step_size,
+                                           "project_id": project_id,
+                                           "startTimestamp": startTimestamp,
+                                           "endTimestamp": endTimestamp,
+                                           **__get_constraint_values(args)}))
+        row_sessions = cur.fetchone()
+        pg_query = f"""WITH errors AS ( SELECT DISTINCT ON(errors.error_id,timestamp) errors.error_id,timestamp
+                                         FROM events.errors
+                                                  INNER JOIN public.errors AS m_errors USING (error_id)
+                                         WHERE {" AND ".join(pg_sub_query_subset)}
+                                    )
+                    SELECT *
+                    FROM (SELECT COUNT(DISTINCT errors.error_id) AS errors_count
+                          FROM errors) AS counts
+                             LEFT JOIN
+                         (SELECT jsonb_agg(chart) AS chart
+                          FROM (SELECT generated_timestamp          AS timestamp,
+                                       COALESCE(COUNT(error_id), 0) AS errors_count
+                                FROM generate_series(%(startTimestamp)s, %(endTimestamp)s, %(step_size)s) AS generated_timestamp
+                                         LEFT JOIN LATERAL ( SELECT DISTINCT errors.error_id
+                                                             FROM errors
+                                                             WHERE {" AND ".join(pg_sub_query_chart)}
+                                    ) AS errors ON (TRUE)
+                                GROUP BY generated_timestamp
+                                ORDER BY generated_timestamp) AS chart) AS chart ON (TRUE);"""
+        cur.execute(cur.mogrify(pg_query, {"step_size": step_size,
+                                           "project_id": project_id,
+                                           "startTimestamp": startTimestamp,
+                                           "endTimestamp": endTimestamp,
+                                           **__get_constraint_values(args)}))
+        row_errors = cur.fetchone()
+        chart = __merge_charts(row_sessions.pop("chart"), row_errors.pop("chart"))
+        row_sessions = helper.dict_to_camel_case(row_sessions)
+        row_errors = helper.dict_to_camel_case(row_errors)
+    return {**row_sessions, **row_errors, "chart": chart}
+
+
+def get_resources_by_party(project_id, startTimestamp=TimeUTC.now(delta_days=-1),
+                           endTimestamp=TimeUTC.now(), density=7, **args):
+    step_size = __get_step_size(startTimestamp, endTimestamp, density, factor=1)
+    pg_sub_query_subset = __get_constraints(project_id=project_id, time_constraint=True,
+                                            chart=False, data=args)
+    pg_sub_query_chart = __get_constraints(project_id=project_id, time_constraint=False, project=False,
+                                           chart=True, data=args, main_table="requests", time_column="timestamp",
+                                           duration=False)
+    pg_sub_query_subset.append("requests.timestamp >= %(startTimestamp)s")
+    pg_sub_query_subset.append("requests.timestamp < %(endTimestamp)s")
+    # pg_sub_query_subset.append("resources.type IN ('fetch', 'script')")
+    pg_sub_query_subset.append("requests.success = FALSE")
+
+    with pg_client.PostgresClient() as cur:
+        pg_query = f"""WITH requests AS (
+                            SELECT requests.host, timestamp
+                            FROM events_common.requests
+                                     INNER JOIN public.sessions USING (session_id)
+                            WHERE {" AND ".join(pg_sub_query_subset)}
+                        )
+                        SELECT generated_timestamp                                                       AS timestamp,
+                               SUM(CASE WHEN first.host = sub_requests.host THEN 1 ELSE 0 END)  AS first_party,
+                               SUM(CASE WHEN first.host != sub_requests.host THEN 1 ELSE 0 END) AS third_party
+                        FROM generate_series(%(startTimestamp)s, %(endTimestamp)s, %(step_size)s) AS generated_timestamp
+                                 LEFT JOIN (
+                            SELECT requests.host,
+                                   COUNT(requests.session_id) AS count
+                            FROM events_common.requests
+                                     INNER JOIN public.sessions USING (session_id)
+                            WHERE sessions.project_id = '1'
+                              AND sessions.start_ts > (EXTRACT(EPOCH FROM now() - INTERVAL '31 days') * 1000)::BIGINT
+                              AND sessions.start_ts < (EXTRACT(EPOCH FROM now()) * 1000)::BIGINT
+                              AND requests.timestamp > (EXTRACT(EPOCH FROM now() - INTERVAL '31 days') * 1000)::BIGINT
+                              AND requests.timestamp < (EXTRACT(EPOCH FROM now()) * 1000)::BIGINT
+                            AND sessions.duration>0
+                            GROUP BY requests.host
+                            ORDER BY count DESC
+                            LIMIT 1
+                        ) AS first ON (TRUE)
+                                 LEFT JOIN LATERAL (
+                            SELECT requests.host
+                            FROM requests
+                            WHERE {" AND ".join(pg_sub_query_chart)}
+                            ) AS sub_requests ON (TRUE)
+                        GROUP BY generated_timestamp
+                        ORDER BY generated_timestamp;"""
+        cur.execute(cur.mogrify(pg_query, {"step_size": step_size,
+                                           "project_id": project_id,
+                                           "startTimestamp": startTimestamp,
+                                           "endTimestamp": endTimestamp, **__get_constraint_values(args)}))
+
+        rows = cur.fetchall()
+    return rows
+
+
+def get_user_activity_avg_visited_pages(project_id, startTimestamp=TimeUTC.now(delta_days=-1),
+                                        endTimestamp=TimeUTC.now(), **args):
+    with pg_client.PostgresClient() as cur:
+        row = __get_user_activity_avg_visited_pages(cur, project_id, startTimestamp, endTimestamp, **args)
+        results = helper.dict_to_camel_case(row)
+        results["chart"] = __get_user_activity_avg_visited_pages_chart(cur, project_id, startTimestamp,
+                                                                       endTimestamp, **args)
+
+        diff = endTimestamp - startTimestamp
+        endTimestamp = startTimestamp
+        startTimestamp = endTimestamp - diff
+        row = __get_user_activity_avg_visited_pages(cur, project_id, startTimestamp, endTimestamp, **args)
+
+        previous = helper.dict_to_camel_case(row)
+        results["progress"] = helper.__progress(old_val=previous["value"], new_val=results["value"])
+    results["unit"] = schemas.TemplatePredefinedUnits.COUNT
+    return results
+
+
+def __get_user_activity_avg_visited_pages(cur, project_id, startTimestamp, endTimestamp, **args):
+    pg_sub_query = __get_constraints(project_id=project_id, data=args)
+    pg_sub_query.append("sessions.pages_count>0")
+    pg_query = f"""SELECT COALESCE(CEIL(AVG(sessions.pages_count)),0) AS value
+                    FROM public.sessions
+                    WHERE {" AND ".join(pg_sub_query)};"""
+    params = {"project_id": project_id, "startTimestamp": startTimestamp, "endTimestamp": endTimestamp,
+              **__get_constraint_values(args)}
+
+    cur.execute(cur.mogrify(pg_query, params))
+    row = cur.fetchone()
+    return row
+
+
+def __get_user_activity_avg_visited_pages_chart(cur, project_id, startTimestamp, endTimestamp, density=20, **args):
+    step_size = __get_step_size(endTimestamp=endTimestamp, startTimestamp=startTimestamp, density=density, factor=1)
+    params = {"step_size": step_size, "project_id": project_id, "startTimestamp": startTimestamp,
+              "endTimestamp": endTimestamp}
+    pg_sub_query_subset = __get_constraints(project_id=project_id, time_constraint=True,
+                                            chart=False, data=args)
+    pg_sub_query_chart = __get_constraints(project_id=project_id, time_constraint=False, project=False,
+                                           chart=True, data=args, main_table="sessions", time_column="start_ts",
+                                           duration=False)
+    pg_sub_query_subset.append("sessions.duration IS NOT NULL")
+
+    pg_query = f"""WITH sessions AS(SELECT sessions.pages_count, sessions.start_ts
+                                    FROM public.sessions
+                                    WHERE {" AND ".join(pg_sub_query_subset)}
+                    )
+                    SELECT generated_timestamp AS timestamp,
+                         COALESCE(AVG(sessions.pages_count),0) AS value
+                      FROM generate_series(%(startTimestamp)s, %(endTimestamp)s, %(step_size)s) AS generated_timestamp
+                        LEFT JOIN LATERAL (
+                                SELECT sessions.pages_count
+                                FROM sessions
+                                WHERE {" AND ".join(pg_sub_query_chart)}
+                        ) AS sessions ON (TRUE)
+                      GROUP BY generated_timestamp
+                      ORDER BY generated_timestamp;"""
+    cur.execute(cur.mogrify(pg_query, {**params, **__get_constraint_values(args)}))
+    rows = cur.fetchall()
+    return rows
+
+
+def get_top_metrics_count_requests(project_id, startTimestamp=TimeUTC.now(delta_days=-1),
+                                   endTimestamp=TimeUTC.now(), value=None, density=20, **args):
+    step_size = __get_step_size(endTimestamp=endTimestamp, startTimestamp=startTimestamp, density=density, factor=1)
+    params = {"step_size": step_size, "project_id": project_id, "startTimestamp": startTimestamp,
+              "endTimestamp": endTimestamp}
+    pg_sub_query = __get_constraints(project_id=project_id, data=args)
+    pg_sub_query_chart = __get_constraints(project_id=project_id, time_constraint=False, project=False,
+                                           chart=True, data=args, main_table="pages", time_column="timestamp",
+                                           duration=False)
+
+    if value is not None:
+        pg_sub_query.append("pages.path = %(value)s")
+        pg_sub_query_chart.append("pages.path = %(value)s")
+    with pg_client.PostgresClient() as cur:
+        pg_query = f"""SELECT COUNT(pages.session_id) AS value
+                        FROM events.pages INNER JOIN public.sessions USING (session_id)
+                        WHERE {" AND ".join(pg_sub_query)};"""
+        cur.execute(cur.mogrify(pg_query, {"project_id": project_id,
+                                           "startTimestamp": startTimestamp,
+                                           "endTimestamp": endTimestamp,
+                                           "value": value, **__get_constraint_values(args)}))
+        row = cur.fetchone()
+        pg_query = f"""WITH pages AS(SELECT pages.timestamp
+                                                FROM events.pages INNER JOIN public.sessions USING (session_id)
+                                                WHERE {" AND ".join(pg_sub_query)}
+                                )
+                    SELECT generated_timestamp AS timestamp,
+                         COUNT(pages.*) AS value
+                      FROM generate_series(%(startTimestamp)s, %(endTimestamp)s, %(step_size)s) AS generated_timestamp
+                        LEFT JOIN LATERAL (
+                                SELECT 1
+                                FROM pages
+                                WHERE {" AND ".join(pg_sub_query_chart)}
+                        ) AS pages ON (TRUE)
+                      GROUP BY generated_timestamp
+                      ORDER BY generated_timestamp;"""
+        cur.execute(cur.mogrify(pg_query, {**params, **__get_constraint_values(args)}))
+        rows = cur.fetchall()
+        row["chart"] = rows
+    row["unit"] = schemas.TemplatePredefinedUnits.COUNT
+    return helper.dict_to_camel_case(row)
+
+
+def get_unique_users(project_id, startTimestamp=TimeUTC.now(delta_days=-1),
+                     endTimestamp=TimeUTC.now(),
+                     density=7, **args):
+    step_size = __get_step_size(startTimestamp, endTimestamp, density, factor=1)
+    pg_sub_query = __get_constraints(project_id=project_id, data=args)
+    pg_sub_query_chart = __get_constraints(project_id=project_id, time_constraint=True,
+                                           chart=True, data=args)
+    pg_sub_query.append("user_id IS NOT NULL")
+    pg_sub_query.append("user_id != ''")
+    pg_sub_query_chart.append("user_id IS NOT NULL")
+    pg_sub_query_chart.append("user_id != ''")
+    with pg_client.PostgresClient() as cur:
+        pg_query = f"""SELECT generated_timestamp AS timestamp,
+                               COALESCE(COUNT(sessions), 0) AS value
+                        FROM generate_series(%(startTimestamp)s, %(endTimestamp)s, %(step_size)s) AS generated_timestamp
+                             LEFT JOIN LATERAL ( SELECT DISTINCT user_id
+                                                 FROM public.sessions
+                                                 WHERE {" AND ".join(pg_sub_query_chart)}
+                             ) AS sessions ON (TRUE)
+                        GROUP BY generated_timestamp
+                        ORDER BY generated_timestamp;"""
+        params = {"step_size": step_size, "project_id": project_id, "startTimestamp": startTimestamp,
+                  "endTimestamp": endTimestamp, **__get_constraint_values(args)}
+        cur.execute(cur.mogrify(pg_query, params))
+        rows = cur.fetchall()
+        results = {
+            "value": sum([r["value"] for r in rows]),
+            "chart": rows
+        }
+
+        diff = endTimestamp - startTimestamp
+        endTimestamp = startTimestamp
+        startTimestamp = endTimestamp - diff
+
+        pg_query = f"""SELECT COUNT(DISTINCT sessions.user_id) AS count
+                        FROM public.sessions
+                        WHERE {" AND ".join(pg_sub_query)};"""
+        params = {"project_id": project_id, "startTimestamp": startTimestamp, "endTimestamp": endTimestamp,
+                  **__get_constraint_values(args)}
+
+        cur.execute(cur.mogrify(pg_query, params))
+
+        count = cur.fetchone()["count"]
+
+        results["progress"] = helper.__progress(old_val=count, new_val=results["value"])
+    results["unit"] = schemas.TemplatePredefinedUnits.COUNT
+    return results
+
+
+def get_speed_index_location(project_id, startTimestamp=TimeUTC.now(delta_days=-1),
+                             endTimestamp=TimeUTC.now(), **args):
+    pg_sub_query = __get_constraints(project_id=project_id, data=args)
+    pg_sub_query.append("pages.speed_index IS NOT NULL")
+    pg_sub_query.append("pages.speed_index>0")
+
+    with pg_client.PostgresClient() as cur:
+        pg_query = f"""SELECT sessions.user_country, AVG(pages.speed_index) AS value
+                        FROM events.pages INNER JOIN public.sessions USING (session_id)
+                        WHERE {" AND ".join(pg_sub_query)} 
+                        GROUP BY sessions.user_country
+                        ORDER BY value, sessions.user_country;"""
+        params = {"project_id": project_id,
+                  "startTimestamp": startTimestamp,
+                  "endTimestamp": endTimestamp, **__get_constraint_values(args)}
+        cur.execute(cur.mogrify(pg_query, params))
+        rows = cur.fetchall()
+        if len(rows) > 0:
+            pg_query = f"""SELECT AVG(pages.speed_index) AS avg
+                                FROM events.pages INNER JOIN public.sessions USING (session_id)
+                                WHERE {" AND ".join(pg_sub_query)};"""
+            cur.execute(cur.mogrify(pg_query, params))
+            avg = cur.fetchone()["avg"]
+        else:
+            avg = 0
+    return {"value": avg, "chart": helper.list_to_camel_case(rows), "unit": schemas.TemplatePredefinedUnits.MILLISECOND}

api/chalicelib/core/metrics/__init__.py

@@ -1,10 +0,0 @@
-import logging
-
-from decouple import config
-
-logger = logging.getLogger(__name__)
-
-if config("EXP_METRICS", cast=bool, default=False):
-    logger.info(">>> Using experimental metrics")
-else:
-    pass

api/chalicelib/core/metrics/heatmaps/__init__.py

@@ -1,11 +0,0 @@
-import logging
-
-from decouple import config
-
-logger = logging.getLogger(__name__)
-
-if config("EXP_METRICS", cast=bool, default=False):
-    logger.info(">>> Using experimental heatmaps")
-    from .heatmaps_ch import *
-else:
-    from .heatmaps import *

api/chalicelib/core/metrics/heatmaps/heatmaps_ch.py

@@ -1,385 +0,0 @@
-import logging
-
-from decouple import config
-
-import schemas
-from chalicelib.core import events
-from chalicelib.core.metrics.modules import sessions, sessions_mobs
-from chalicelib.utils import sql_helper as sh
-
-from chalicelib.utils import pg_client, helper, ch_client, exp_ch_helper
-
-logger = logging.getLogger(__name__)
-
-
-def get_by_url(project_id, data: schemas.GetHeatMapPayloadSchema):
-    if data.url is None or data.url == "":
-        return []
-    args = {"startDate": data.startTimestamp, "endDate": data.endTimestamp,
-            "project_id": project_id, "url": data.url}
-    constraints = [
-        "main_events.project_id = toUInt16(%(project_id)s)",
-        "main_events.created_at >= toDateTime(%(startDate)s / 1000)",
-        "main_events.created_at <= toDateTime(%(endDate)s / 1000)",
-        "main_events.`$event_name` = 'CLICK'",
-        "isNotNull(JSON_VALUE(CAST(main_events.`$properties` AS String), '$.normalized_x'))"
-    ]
-
-    if data.operator == schemas.SearchEventOperator.IS:
-        constraints.append("JSON_VALUE(CAST(main_events.`$properties` AS String), '$.url_path') = %(url)s")
-    else:
-        constraints.append("JSON_VALUE(CAST(main_events.`$properties` AS String), '$.url_path') ILIKE %(url)s")
-        args["url"] = helper.values_for_operator(data.url, data.operator)
-
-    query_from = f"{exp_ch_helper.get_main_events_table(data.startTimestamp)} AS main_events"
-    # TODO: is this used ?
-    # has_click_rage_filter = False
-    # if len(data.filters) > 0:
-    #     for i, f in enumerate(data.filters):
-    #         if f.type == schemas.FilterType.issue and len(f.value) > 0:
-    #             has_click_rage_filter = True
-    #             query_from += """INNER JOIN events_common.issues USING (timestamp, session_id)
-    #                            INNER JOIN issues AS mis USING (issue_id)
-    #                            INNER JOIN LATERAL (
-    #                                 SELECT COUNT(1) AS real_count
-    #                                  FROM events.clicks AS sc
-    #                                           INNER JOIN sessions as ss USING (session_id)
-    #                                  WHERE ss.project_id = 2
-    #                                    AND (sc.url = %(url)s OR sc.path = %(url)s)
-    #                                    AND sc.timestamp >= %(startDate)s
-    #                                    AND sc.timestamp <= %(endDate)s
-    #                                    AND ss.start_ts >= %(startDate)s
-    #                                    AND ss.start_ts <= %(endDate)s
-    #                                    AND sc.selector = clicks.selector) AS r_clicks ON (TRUE)"""
-    #             constraints += ["mis.project_id = %(project_id)s",
-    #                             "issues.timestamp >= %(startDate)s",
-    #                             "issues.timestamp <= %(endDate)s"]
-    #             f_k = f"issue_value{i}"
-    #             args = {**args, **sh.multi_values(f.value, value_key=f_k)}
-    #             constraints.append(sh.multi_conditions(f"%({f_k})s = ANY (issue_types)",
-    #                                                    f.value, value_key=f_k))
-    #             constraints.append(sh.multi_conditions(f"mis.type = %({f_k})s",
-    #                                                    f.value, value_key=f_k))
-    # TODO: change this once click-rage is fixed
-    # if data.click_rage and not has_click_rage_filter:
-    #     constraints.append("""(issues_t.session_id IS NULL
-    #                             OR (issues_t.datetime >= toDateTime(%(startDate)s/1000)
-    #                                 AND issues_t.datetime <= toDateTime(%(endDate)s/1000)
-    #                                 AND issues_t.project_id = toUInt16(%(project_id)s)
-    #                                 AND issues_t.event_type = 'ISSUE'
-    #                                 AND issues_t.project_id = toUInt16(%(project_id)s)
-    #                                 AND mis.project_id = toUInt16(%(project_id)s)
-    #                                 AND mis.type='click_rage'))""")
-    #     query_from += """ LEFT JOIN experimental.events AS issues_t ON (main_events.session_id=issues_t.session_id)
-    #                    LEFT JOIN experimental.issues AS mis ON (issues_t.issue_id=mis.issue_id)"""
-    with ch_client.ClickHouseClient() as cur:
-        query = cur.format(query=f"""SELECT 
-                                JSON_VALUE(CAST(`$properties` AS String), '$.normalized_x') AS normalized_x, 
-                                JSON_VALUE(CAST(`$properties` AS String), '$.normalized_y') AS normalized_y
-                             FROM {query_from}
-                             WHERE {" AND ".join(constraints)}
-                             LIMIT 500;""",
-                           parameters=args)
-        logger.debug("---------")
-        logger.debug(query)
-        logger.debug("---------")
-        try:
-            rows = cur.execute(query=query)
-        except Exception as err:
-            logger.warning("--------- HEATMAP 2 SEARCH QUERY EXCEPTION CH -----------")
-            logger.warning(query)
-            logger.warning("--------- PAYLOAD -----------")
-            logger.warning(data)
-            logger.warning("--------------------")
-            raise err
-
-        return helper.list_to_camel_case(rows)
-
-
-def get_x_y_by_url_and_session_id(project_id, session_id, data: schemas.GetHeatMapPayloadSchema):
-    args = {"project_id": project_id, "session_id": session_id, "url": data.url}
-    constraints = [
-        "main_events.project_id = toUInt16(%(project_id)s)",
-        "main_events.session_id = %(session_id)s",
-        "main_events.`$event_name`='CLICK'",
-        "isNotNull(JSON_VALUE(CAST(main_events.`$properties` AS String), '$.normalized_x'))"
-    ]
-    if data.operator == schemas.SearchEventOperator.IS:
-        constraints.append("JSON_VALUE(CAST(main_events.`$properties` AS String), '$.url_path') = %(url)s")
-    else:
-        constraints.append("JSON_VALUE(CAST(main_events.`$properties` AS String), '$.url_path') ILIKE %(url)s")
-        args["url"] = helper.values_for_operator(data.url, data.operator)
-
-    query_from = f"{exp_ch_helper.get_main_events_table(0)} AS main_events"
-
-    with ch_client.ClickHouseClient() as cur:
-        query = cur.format(query=f"""SELECT main_events.normalized_x AS normalized_x, 
-                                                main_events.normalized_y AS normalized_y
-                               FROM {query_from}
-                               WHERE {" AND ".join(constraints)};""",
-                           parameters=args)
-        logger.debug("---------")
-        logger.debug(query)
-        logger.debug("---------")
-        try:
-            rows = cur.execute(query=query)
-        except Exception as err:
-            logger.warning("--------- HEATMAP-session_id SEARCH QUERY EXCEPTION CH -----------")
-            logger.warning(query)
-            logger.warning("--------- PAYLOAD -----------")
-            logger.warning(data)
-            logger.warning("--------------------")
-            raise err
-
-        return helper.list_to_camel_case(rows)
-
-
-def get_selectors_by_url_and_session_id(project_id, session_id, data: schemas.GetHeatMapPayloadSchema):
-    args = {"project_id": project_id, "session_id": session_id, "url": data.url}
-    constraints = ["main_events.project_id = toUInt16(%(project_id)s)",
-                   "main_events.session_id = %(session_id)s",
-                   "main_events.`$event_name`='CLICK'"]
-
-    if data.operator == schemas.SearchEventOperator.IS:
-        constraints.append("JSON_VALUE(CAST(main_events.`$properties` AS String), '$.url_path') = %(url)s")
-    else:
-        constraints.append("JSON_VALUE(CAST(main_events.`$properties` AS String), '$.url_path') ILIKE %(url)s")
-        args["url"] = helper.values_for_operator(data.url, data.operator)
-
-    query_from = f"{exp_ch_helper.get_main_events_table(0)} AS main_events"
-
-    with ch_client.ClickHouseClient() as cur:
-        query = cur.format(query=f"""SELECT CAST(`$properties`.selector AS String) AS selector, 
-                                      COUNT(1) AS count
-                               FROM {query_from}
-                               WHERE {" AND ".join(constraints)}
-                               GROUP BY 1
-                               ORDER BY count DESC;""",
-                           parameters=args)
-        logger.debug("---------")
-        logger.debug(query)
-        logger.debug("---------")
-        try:
-            rows = cur.execute(query=query)
-        except Exception as err:
-            logger.warning("--------- HEATMAP-session_id SEARCH QUERY EXCEPTION CH -----------")
-            logger.warning(query)
-            logger.warning("--------- PAYLOAD -----------")
-            logger.warning(data)
-            logger.warning("--------------------")
-            raise err
-
-        return helper.list_to_camel_case(rows)
-
-
-# use CH
-SESSION_PROJECTION_COLS = """s.project_id,
-s.session_id AS session_id,
-toUnixTimestamp(s.datetime)*1000 AS start_ts,
-s.duration AS duration"""
-
-
-def __get_1_url(location_condition: schemas.SessionSearchEventSchema2 | None, session_id: str, project_id: int,
-                start_time: int,
-                end_time: int) -> str | None:
-    full_args = {
-        "sessionId": session_id,
-        "projectId": project_id,
-        "start_time": start_time,
-        "end_time": end_time,
-    }
-    sub_condition = ["session_id = %(sessionId)s", "`$event_name` = 'CLICK'", "project_id = %(projectId)s"]
-    if location_condition and len(location_condition.value) > 0:
-        f_k = "LOC"
-        op = sh.get_sql_operator(location_condition.operator)
-        full_args = {**full_args, **sh.multi_values(location_condition.value, value_key=f_k)}
-        sub_condition.append(
-            sh.multi_conditions(f'path {op} %({f_k})s', location_condition.value, is_not=False,
-                                value_key=f_k))
-    with ch_client.ClickHouseClient() as cur:
-        main_query = cur.format(query=f"""WITH paths AS (
-                                     SELECT DISTINCT 
-                                         JSON_VALUE(CAST(`$properties` AS String), '$.url_path') AS url_path
-                                     FROM product_analytics.events
-                                     WHERE {" AND ".join(sub_condition)}
-                                  )
-                                  SELECT 
-                                      paths.url_path, 
-                                      COUNT(*) AS count
-                                  FROM product_analytics.events
-                                  INNER JOIN paths 
-                                      ON JSON_VALUE(CAST(product_analytics.events.$properties AS String), '$.url_path') = paths.url_path
-                                  WHERE `$event_name` = 'CLICK'
-                                    AND project_id = %(projectId)s
-                                    AND created_at >= toDateTime(%(start_time)s / 1000)
-                                    AND created_at <= toDateTime(%(end_time)s / 1000)
-                                  GROUP BY paths.url_path
-                                  ORDER BY count DESC
-                                  LIMIT 1;""",
-                                parameters=full_args)
-        logger.debug("--------------------")
-        logger.debug(main_query)
-        logger.debug("--------------------")
-        try:
-            url = cur.execute(query=main_query)
-        except Exception as err:
-            logger.warning("--------- CLICK MAP BEST URL SEARCH QUERY EXCEPTION CH-----------")
-            logger.warning(main_query.decode('UTF-8'))
-            logger.warning("--------- PAYLOAD -----------")
-            logger.warning(full_args)
-            logger.warning("--------------------")
-            raise err
-
-    if url is None or len(url) == 0:
-        return None
-    return url[0]["url_path"]
-
-
-def search_short_session(data: schemas.HeatMapSessionsSearch, project_id, user_id,
-                         include_mobs: bool = True, exclude_sessions: list[str] = [],
-                         _depth: int = 3):
-    no_platform = True
-    location_condition = None
-    no_click = True
-    for f in data.filters:
-        if f.type == schemas.FilterType.PLATFORM:
-            no_platform = False
-            break
-    for f in data.events:
-        if f.type == schemas.EventType.LOCATION:
-            if len(f.value) == 0:
-                f.operator = schemas.SearchEventOperator.IS_ANY
-            location_condition = f.model_copy()
-        elif f.type == schemas.EventType.CLICK:
-            no_click = False
-            if len(f.value) == 0:
-                f.operator = schemas.SearchEventOperator.IS_ANY
-        if location_condition and not no_click:
-            break
-
-    if no_platform:
-        data.filters.append(schemas.SessionSearchFilterSchema(type=schemas.FilterType.PLATFORM,
-                                                              value=[schemas.PlatformType.DESKTOP],
-                                                              operator=schemas.SearchEventOperator.IS))
-    if not location_condition:
-        data.events.append(schemas.SessionSearchEventSchema2(type=schemas.EventType.LOCATION,
-                                                             value=[],
-                                                             operator=schemas.SearchEventOperator.IS_ANY))
-    if no_click:
-        data.events.append(schemas.SessionSearchEventSchema2(type=schemas.EventType.CLICK,
-                                                             value=[],
-                                                             operator=schemas.SearchEventOperator.IS_ANY))
-
-    data.filters.append(schemas.SessionSearchFilterSchema(type=schemas.FilterType.EVENTS_COUNT,
-                                                          value=[0],
-                                                          operator=schemas.MathOperator.GREATER))
-
-    full_args, query_part = sessions.search_query_parts_ch(data=data, error_status=None, errors_only=False,
-                                                           favorite_only=data.bookmarked, issue=None,
-                                                           project_id=project_id, user_id=user_id)
-    full_args["exclude_sessions"] = tuple(exclude_sessions)
-    if len(exclude_sessions) > 0:
-        query_part += "\n AND session_id NOT IN (%(exclude_sessions)s)"
-    with ch_client.ClickHouseClient() as cur:
-        data.order = schemas.SortOrderType.DESC
-        data.sort = 'duration'
-        main_query = cur.format(query=f"""SELECT * 
-                                           FROM (SELECT {SESSION_PROJECTION_COLS}
-                                           {query_part}
-                                           -- ORDER BY {data.sort} {data.order.value}
-                                           LIMIT 20) AS raw
-                                           ORDER BY rand()
-                                           LIMIT 1;""",
-                                parameters=full_args)
-        logger.debug("--------------------")
-        logger.debug(main_query)
-        logger.debug("--------------------")
-        try:
-            session = cur.execute(query=main_query)
-        except Exception as err:
-            logger.warning("--------- CLICK MAP SHORT SESSION SEARCH QUERY EXCEPTION CH -----------")
-            logger.warning(main_query)
-            logger.warning("--------- PAYLOAD -----------")
-            logger.warning(data.model_dump_json())
-            logger.warning("--------------------")
-            raise err
-
-    if len(session) > 0:
-        session = session[0]
-        if not location_condition or location_condition.operator == schemas.SearchEventOperator.IS_ANY:
-            session["path"] = __get_1_url(project_id=project_id, session_id=session["session_id"],
-                                          location_condition=location_condition,
-                                          start_time=data.startTimestamp, end_time=data.endTimestamp)
-        else:
-            session["path"] = location_condition.value[0]
-
-        if include_mobs:
-            session['domURL'] = sessions_mobs.get_urls(session_id=session["session_id"], project_id=project_id)
-            session['mobsUrl'] = sessions_mobs.get_urls_depercated(session_id=session["session_id"])
-            if _depth > 0 and len(session['domURL']) == 0 and len(session['mobsUrl']) == 0:
-                return search_short_session(data=data, project_id=project_id, user_id=user_id,
-                                            include_mobs=include_mobs,
-                                            exclude_sessions=exclude_sessions + [session["session_id"]],
-                                            _depth=_depth - 1)
-            elif _depth == 0 and len(session['domURL']) == 0 and len(session['mobsUrl']) == 0:
-                logger.info("couldn't find an existing replay after 3 iterations for heatmap")
-
-        session['events'] = events.get_by_session_id(project_id=project_id, session_id=session["session_id"],
-                                                     event_type=schemas.EventType.LOCATION)
-    else:
-        return None
-
-    return helper.dict_to_camel_case(session)
-
-
-def get_selected_session(project_id, session_id):
-    with ch_client.ClickHouseClient() as cur:
-        main_query = cur.format(query=f"""SELECT {SESSION_PROJECTION_COLS}
-                                    FROM experimental.sessions AS s
-                                    WHERE session_id=%(session_id)s;""",
-                                parameters={"session_id": session_id})
-        logger.debug("--------------------")
-        logger.debug(main_query)
-        logger.debug("--------------------")
-        try:
-            session = cur.execute(query=main_query)
-        except Exception as err:
-            logger.warning("--------- CLICK MAP GET SELECTED SESSION QUERY EXCEPTION -----------")
-            logger.warning(main_query.decode('UTF-8'))
-            raise err
-    if len(session) > 0:
-        session = session[0]
-    else:
-        session = None
-
-    if session:
-        session['domURL'] = sessions_mobs.get_urls(session_id=session["session_id"], project_id=project_id)
-        session['mobsUrl'] = sessions_mobs.get_urls_depercated(session_id=session["session_id"])
-        if len(session['domURL']) == 0 and len(session['mobsUrl']) == 0:
-            session["_issue"] = "mob file not found"
-            logger.info("can't find selected mob file for heatmap")
-        session['events'] = get_page_events(session_id=session["session_id"], project_id=project_id)
-
-    return helper.dict_to_camel_case(session)
-
-
-def get_page_events(session_id, project_id):
-    with ch_client.ClickHouseClient() as cur:
-        query = cur.format(query=f"""SELECT
-                                    event_id as message_id,
-                                    toUnixTimestamp(created_at)*1000 AS timestamp,
-                                    JSON_VALUE(CAST(`$properties` AS String), '$.url_host') AS host,
-                                    JSON_VALUE(CAST(`$properties` AS String), '$.url_path') AS path,
-                                    JSON_VALUE(CAST(`$properties` AS String), '$.url_path') AS value,
-                                    JSON_VALUE(CAST(`$properties` AS String), '$.url_path') AS url,
-                                    'LOCATION' AS type
-                                FROM product_analytics.events
-                                WHERE session_id = %(session_id)s 
-                                    AND `$event_name`='LOCATION'
-                                    AND project_id= %(project_id)s
-                                ORDER BY created_at,message_id;""",
-                           parameters={"session_id": session_id, "project_id": project_id})
-
-        rows = cur.execute(query=query)
-        rows = helper.list_to_camel_case(rows)
-    return rows

api/chalicelib/core/metrics/modules/__init__.py

@@ -1,12 +0,0 @@
-import logging
-
-from decouple import config
-
-logger = logging.getLogger(__name__)
-
-if config("EXP_METRICS", cast=bool, default=False):
-    import chalicelib.core.sessions.sessions_ch as sessions
-else:
-    import chalicelib.core.sessions.sessions_pg as sessions
-
-from chalicelib.core.sessions import sessions_mobs

api/chalicelib/core/metrics/modules/significance/__init__.py

@@ -1,10 +0,0 @@
-import logging
-
-from decouple import config
-
-logger = logging.getLogger(__name__)
-
-from .significance import *
-
-if config("EXP_METRICS", cast=bool, default=False):
-    from .significance_ch import *

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

@@ -1,10 +0,0 @@
-import logging
-
-from decouple import config
-
-logger = logging.getLogger(__name__)
-if config("EXP_METRICS", cast=bool, default=False):
-    logger.info(">>> Using experimental product-analytics")
-    from .product_analytics_ch import *
-else:
-    from .product_analytics import *

api/chalicelib/core/modules/__init__.py

@@ -1,6 +0,0 @@
-TENANT_CONDITION = "TRUE"
-MOB_KEY = ""
-
-
-def get_file_key(project_id, session_id):
-    return {}

api/chalicelib/core/product_analytics.py

@@ -12,75 +12,42 @@ logger = logging.getLogger(__name__)
 
 def __transform_journey(rows, reverse_path=False):
     total_100p = 0
+    number_of_step1 = 0
     for r in rows:
         if r["event_number_in_session"] > 1:
             break
+        number_of_step1 += 1
         total_100p += r["sessions_count"]
+    # for i in range(number_of_step1):
+    #     rows[i]["value"] = 100 / number_of_step1
+
+    # for i in range(number_of_step1, len(rows)):
+    for i in range(len(rows)):
+        rows[i]["value"] = rows[i]["sessions_count"] * 100 / total_100p
 
     nodes = []
     nodes_values = []
     links = []
-    drops = []
-    max_depth = 0
     for r in rows:
-        r["value"] = r["sessions_count"] * 100 / total_100p
-        source = f"{r['event_number_in_session'] - 1}_{r['event_type']}_{r['e_value']}"
+        source = f"{r['event_number_in_session']}_{r['event_type']}_{r['e_value']}"
         if source not in nodes:
             nodes.append(source)
-            nodes_values.append({"depth": r['event_number_in_session'] - 1,
-                                 "name": r['e_value'],
-                                 "eventType": r['event_type'],
-                                 "id": len(nodes_values)})
-
-        target = f"{r['event_number_in_session']}_{r['next_type']}_{r['next_value']}"
-        if target not in nodes:
-            nodes.append(target)
-            nodes_values.append({"depth": r['event_number_in_session'],
-                                 "name": r['next_value'],
-                                 "eventType": r['next_type'],
-                                 "id": len(nodes_values)})
-
-        sr_idx = nodes.index(source)
-        tg_idx = nodes.index(target)
-
-        link = {"eventType": r['event_type'], "sessionsCount": r["sessions_count"], "value": r["value"]}
-        if not reverse_path:
-            link["source"] = sr_idx
-            link["target"] = tg_idx
-        else:
-            link["source"] = tg_idx
-            link["target"] = sr_idx
-        links.append(link)
-
-        max_depth = r['event_number_in_session']
-        if r["next_type"] == "DROP":
-            for d in drops:
-                if d["depth"] == r['event_number_in_session']:
-                    d["sessions_count"] += r["sessions_count"]
-                    break
-            else:
-                drops.append({"depth": r['event_number_in_session'], "sessions_count": r["sessions_count"]})
-
-    for i in range(len(drops)):
-
-        if drops[i]["depth"] < max_depth:
-            source = f"{drops[i]['depth']}_DROP_None"
-            target = f"{drops[i]['depth'] + 1}_DROP_None"
-            sr_idx = nodes.index(source)
-
-            if i < len(drops) - 1 and drops[i]["depth"] + 1 == drops[i + 1]["depth"]:
-                tg_idx = nodes.index(target)
-            else:
+            nodes_values.append({"name": r['e_value'], "eventType": r['event_type'],
+                                 "avgTimeFromPrevious": 0, "sessionsCount": 0})
+        if r['next_value']:
+            target = f"{r['event_number_in_session'] + 1}_{r['next_type']}_{r['next_value']}"
+            if target not in nodes:
                 nodes.append(target)
-                nodes_values.append({"depth": drops[i]["depth"] + 1,
-                                     "name": None,
-                                     "eventType": "DROP",
-                                     "id": len(nodes_values)})
-                tg_idx = len(nodes) - 1
+                nodes_values.append({"name": r['next_value'], "eventType": r['next_type'],
+                                     "avgTimeFromPrevious": 0, "sessionsCount": 0})
 
-            link = {"eventType": "DROP",
-                    "sessionsCount": drops[i]["sessions_count"],
-                    "value": drops[i]["sessions_count"] * 100 / total_100p}
+            sr_idx = nodes.index(source)
+            tg_idx = nodes.index(target)
+            if r["avg_time_from_previous"] is not None:
+                nodes_values[tg_idx]["avgTimeFromPrevious"] += r["avg_time_from_previous"] * r["sessions_count"]
+                nodes_values[tg_idx]["sessionsCount"] += r["sessions_count"]
+            link = {"eventType": r['event_type'], "sessionsCount": r["sessions_count"],
+                    "value": r["value"], "avgTimeFromPrevious": r["avg_time_from_previous"]}
             if not reverse_path:
                 link["source"] = sr_idx
                 link["target"] = tg_idx
@@ -88,10 +55,13 @@ def __transform_journey(rows, reverse_path=False):
                 link["source"] = tg_idx
                 link["target"] = sr_idx
             links.append(link)
+    for n in nodes_values:
+        if n["sessionsCount"] > 0:
+            n["avgTimeFromPrevious"] = n["avgTimeFromPrevious"] / n["sessionsCount"]
+        else:
+            n["avgTimeFromPrevious"] = None
+        n.pop("sessionsCount")
 
-    if reverse_path:
-        for n in nodes_values:
-            n["depth"] = max_depth - n["depth"]
     return {"nodes": nodes_values,
             "links": sorted(links, key=lambda x: (x["source"], x["target"]), reverse=False)}
 
@@ -433,9 +403,7 @@ WITH sub_sessions AS (SELECT session_id {sub_sessions_extra_projection}
 {"UNION ALL".join(projection_query)};"""
         params = {"project_id": project_id, "startTimestamp": data.startTimestamp,
                   "endTimestamp": data.endTimestamp, "density": data.density,
-                  # This is ignored because UI will take care of it
-                  # "eventThresholdNumberInGroup": 4 if data.hide_excess else 8,
-                  "eventThresholdNumberInGroup": 8,
+                  "eventThresholdNumberInGroup": 4 if data.hide_excess else 8,
                   **extra_values}
         query = cur.mogrify(pg_query, params)
         _now = time()

api/chalicelib/core/projects.py

@@ -1,7 +1,6 @@
 import json
-import logging
-from collections import Counter
 from typing import Optional, List
+from collections import Counter
 
 from fastapi import HTTPException, status
 
@@ -10,8 +9,6 @@ from chalicelib.core import users
 from chalicelib.utils import pg_client, helper
 from chalicelib.utils.TimeUTC import TimeUTC
 
-logger = logging.getLogger(__name__)
-
 
 def __exists_by_name(name: str, exclude_id: Optional[int]) -> bool:
     with pg_client.PostgresClient() as cur:
@@ -413,6 +410,7 @@ def update_project_conditions(project_id, conditions):
         create_project_conditions(project_id, to_be_created)
 
     if to_be_updated:
+        print(to_be_updated)
         update_project_condition(project_id, to_be_updated)
 
     return get_conditions(project_id)
@@ -427,45 +425,3 @@ def get_projects_ids(tenant_id):
         cur.execute(query=query)
         rows = cur.fetchall()
     return [r["project_id"] for r in rows]
-
-
-def delete_metadata_condition(project_id, metadata_key):
-    sql = """\
-        UPDATE public.projects_conditions
-        SET filters=(SELECT COALESCE(jsonb_agg(elem), '[]'::jsonb)
-                     FROM jsonb_array_elements(filters) AS elem
-                     WHERE NOT (elem ->> 'type' = 'metadata'
-                         AND elem ->> 'source' = %(metadata_key)s))
-        WHERE project_id = %(project_id)s
-          AND jsonb_typeof(filters) = 'array'
-          AND EXISTS (SELECT 1
-                      FROM jsonb_array_elements(filters) AS elem
-                      WHERE elem ->> 'type' = 'metadata'
-                        AND elem ->> 'source' = %(metadata_key)s);"""
-
-    with pg_client.PostgresClient() as cur:
-        query = cur.mogrify(sql, {"project_id": project_id, "metadata_key": metadata_key})
-        cur.execute(query)
-
-
-def rename_metadata_condition(project_id, old_metadata_key, new_metadata_key):
-    sql = """\
-        UPDATE public.projects_conditions
-        SET filters = (SELECT jsonb_agg(CASE
-                                            WHEN elem ->> 'type' = 'metadata' AND elem ->> 'source' = %(old_metadata_key)s
-                                                THEN elem || ('{"source": "'||%(new_metadata_key)s||'"}')::jsonb
-                                            ELSE elem END)
-                       FROM jsonb_array_elements(filters) AS elem)
-        WHERE project_id = %(project_id)s
-          AND jsonb_typeof(filters) = 'array'
-          AND EXISTS (SELECT 1
-                      FROM jsonb_array_elements(filters) AS elem
-                      WHERE elem ->> 'type' = 'metadata'
-                        AND elem ->> 'source' = %(old_metadata_key)s);"""
-
-    with pg_client.PostgresClient() as cur:
-        query = cur.mogrify(sql, {"project_id": project_id, "old_metadata_key": old_metadata_key,
-                                  "new_metadata_key": new_metadata_key})
-        cur.execute(query)
-
-# TODO: make project conditions use metadata-column-name instead of metadata-key

api/chalicelib/core/reset_password.py

@@ -14,7 +14,7 @@ def reset(data: schemas.ForgetPasswordPayloadSchema, background_tasks: Backgroun
     if helper.allow_captcha() and not captcha.is_valid(data.g_recaptcha_response):
         return {"errors": ["Invalid captcha."]}
     if not smtp.has_smtp():
-        return {"errors": ["Email delivery failed due to invalid SMTP configuration. Please contact your admin."]}
+        return {"errors": ["no SMTP configuration found, you can ask your admin to reset your password"]}
     a_user = users.get_by_email_only(data.email)
     if a_user:
         invitation_link = users.generate_new_invitation(user_id=a_user["userId"])

api/chalicelib/core/sessions/__init__.py

@@ -1,13 +0,0 @@
-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
-
-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.py

@@ -2,20 +2,180 @@ import logging
 from typing import List, Union
 
 import schemas
-from chalicelib.core import events, metadata
-from . import performance_event
+from chalicelib.core import events, metadata, projects
+from chalicelib.core.sessions import sessions_favorite, performance_event
 from chalicelib.utils import pg_client, helper, metrics_helper
 from chalicelib.utils import sql_helper as sh
 
 logger = logging.getLogger(__name__)
 
+SESSION_PROJECTION_BASE_COLS = """s.project_id,
+s.session_id::text AS session_id,
+s.user_uuid,
+s.user_id,
+s.user_os,
+s.user_browser,
+s.user_device,
+s.user_device_type,
+s.user_country,
+s.user_city,
+s.user_state,
+s.start_ts,
+s.duration,
+s.events_count,
+s.pages_count,
+s.errors_count,
+s.user_anonymous_id,
+s.platform,
+s.issue_score,
+s.timezone,
+to_jsonb(s.issue_types) AS issue_types """
+
+SESSION_PROJECTION_COLS = SESSION_PROJECTION_BASE_COLS + """,
+favorite_sessions.session_id NOTNULL            AS favorite,
+COALESCE((SELECT TRUE
+ FROM public.user_viewed_sessions AS fs
+ WHERE s.session_id = fs.session_id
+   AND fs.user_id = %(userId)s LIMIT 1), FALSE) AS viewed """
+
+
+# This function executes the query and return result
+def search_sessions(data: schemas.SessionsSearchPayloadSchema, project_id, user_id, errors_only=False,
+                    error_status=schemas.ErrorStatus.ALL, count_only=False, issue=None, ids_only=False,
+                    platform="web"):
+    if data.bookmarked:
+        data.startTimestamp, data.endTimestamp = sessions_favorite.get_start_end_timestamp(project_id, user_id)
+
+    full_args, query_part = search_query_parts(data=data, error_status=error_status, errors_only=errors_only,
+                                               favorite_only=data.bookmarked, issue=issue, project_id=project_id,
+                                               user_id=user_id, platform=platform)
+    if data.limit is not None and data.page is not None:
+        full_args["sessions_limit"] = data.limit
+        full_args["sessions_limit_s"] = (data.page - 1) * data.limit
+        full_args["sessions_limit_e"] = data.page * data.limit
+    else:
+        full_args["sessions_limit"] = 200
+        full_args["sessions_limit_s"] = 0
+        full_args["sessions_limit_e"] = 200
+
+    meta_keys = []
+    with pg_client.PostgresClient() as cur:
+        if errors_only:
+            main_query = cur.mogrify(f"""SELECT DISTINCT er.error_id,
+                                         COALESCE((SELECT TRUE
+                                                     FROM public.user_viewed_errors AS ve
+                                                     WHERE er.error_id = ve.error_id
+                                                       AND ve.user_id = %(userId)s LIMIT 1), FALSE) AS viewed
+                                        {query_part};""", full_args)
+
+        elif count_only:
+            main_query = cur.mogrify(f"""SELECT COUNT(DISTINCT s.session_id) AS count_sessions, 
+                                                COUNT(DISTINCT s.user_uuid) AS count_users
+                                        {query_part};""", full_args)
+        elif data.group_by_user:
+            g_sort = "count(full_sessions)"
+            if data.order is None:
+                data.order = schemas.SortOrderType.DESC.value
+            else:
+                data.order = data.order
+            if data.sort is not None and data.sort != 'sessionsCount':
+                sort = helper.key_to_snake_case(data.sort)
+                g_sort = f"{'MIN' if data.order == schemas.SortOrderType.DESC else 'MAX'}({sort})"
+            else:
+                sort = 'start_ts'
+
+            meta_keys = metadata.get(project_id=project_id)
+            main_query = cur.mogrify(f"""SELECT COUNT(*) AS count,
+                                                COALESCE(JSONB_AGG(users_sessions) 
+                                                    FILTER (WHERE rn>%(sessions_limit_s)s AND rn<=%(sessions_limit_e)s), '[]'::JSONB) AS sessions
+                                        FROM (SELECT user_id,
+                                                 count(full_sessions)                                   AS user_sessions_count,
+                                                 jsonb_agg(full_sessions) FILTER (WHERE rn <= 1)        AS last_session,
+                                                 MIN(full_sessions.start_ts)                            AS first_session_ts,
+                                                 ROW_NUMBER() OVER (ORDER BY {g_sort} {data.order}) AS rn
+                                            FROM (SELECT *, ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY {sort} {data.order}) AS rn 
+                                                FROM (SELECT DISTINCT ON(s.session_id) {SESSION_PROJECTION_COLS} 
+                                                                    {"," if len(meta_keys) > 0 else ""}{",".join([f'metadata_{m["index"]}' for m in meta_keys])}
+                                                    {query_part}
+                                                    ) AS filtred_sessions
+                                                ) AS full_sessions
+                                                GROUP BY user_id
+                                            ) AS users_sessions;""",
+                                     full_args)
+        elif ids_only:
+            main_query = cur.mogrify(f"""SELECT DISTINCT ON(s.session_id) s.session_id
+                                             {query_part}
+                                             ORDER BY s.session_id desc
+                                             LIMIT %(sessions_limit)s OFFSET %(sessions_limit_s)s;""",
+                                     full_args)
+        else:
+            if data.order is None:
+                data.order = schemas.SortOrderType.DESC.value
+            else:
+                data.order = data.order
+            sort = 'session_id'
+            if data.sort is not None and data.sort != "session_id":
+                # sort += " " + data.order + "," + helper.key_to_snake_case(data.sort)
+                sort = helper.key_to_snake_case(data.sort)
+
+            meta_keys = metadata.get(project_id=project_id)
+            main_query = cur.mogrify(f"""SELECT COUNT(full_sessions) AS count, 
+                                                COALESCE(JSONB_AGG(full_sessions) 
+                                                    FILTER (WHERE rn>%(sessions_limit_s)s AND rn<=%(sessions_limit_e)s), '[]'::JSONB) AS sessions
+                                            FROM (SELECT *, ROW_NUMBER() OVER (ORDER BY {sort} {data.order}, issue_score DESC) AS rn
+                                            FROM (SELECT DISTINCT ON(s.session_id) {SESSION_PROJECTION_COLS}
+                                                                {"," if len(meta_keys) > 0 else ""}{",".join([f'metadata_{m["index"]}' for m in meta_keys])}
+                                            {query_part}
+                                            ORDER BY s.session_id desc) AS filtred_sessions
+                                            ORDER BY {sort} {data.order}, issue_score DESC) AS full_sessions;""",
+                                     full_args)
+        logger.debug("--------------------")
+        logger.debug(main_query)
+        logger.debug("--------------------")
+        try:
+            cur.execute(main_query)
+            sessions = cur.fetchone()
+        except Exception as err:
+            logger.warning("--------- SESSIONS SEARCH QUERY EXCEPTION -----------")
+            logger.warning(main_query.decode('UTF-8'))
+            logger.warning("--------- PAYLOAD -----------")
+            logger.warning(data.model_dump_json())
+            logger.warning("--------------------")
+            raise err
+        if errors_only or ids_only:
+            return helper.list_to_camel_case(cur.fetchall())
+
+        if count_only:
+            return helper.dict_to_camel_case(sessions)
+
+        total = sessions["count"]
+        sessions = sessions["sessions"]
+
+    if data.group_by_user:
+        for i, s in enumerate(sessions):
+            sessions[i] = {**s.pop("last_session")[0], **s}
+            sessions[i].pop("rn")
+            sessions[i]["metadata"] = {k["key"]: sessions[i][f'metadata_{k["index"]}'] for k in meta_keys \
+                                       if sessions[i][f'metadata_{k["index"]}'] is not None}
+    else:
+        for i, s in enumerate(sessions):
+            sessions[i]["metadata"] = {k["key"]: sessions[i][f'metadata_{k["index"]}'] for k in meta_keys \
+                                       if sessions[i][f'metadata_{k["index"]}'] is not None}
+    # if not data.group_by_user and data.sort is not None and data.sort != "session_id":
+    #     sessions = sorted(sessions, key=lambda s: s[helper.key_to_snake_case(data.sort)],
+    #                       reverse=data.order.upper() == "DESC")
+    return {
+        'total': total,
+        'sessions': helper.list_to_camel_case(sessions)
+    }
+
 
 # TODO: remove "table of" search from this function
 def search2_series(data: schemas.SessionsSearchPayloadSchema, project_id: int, density: int,
-                   metric_type: schemas.MetricType, metric_of: schemas.MetricOfTimeseries | schemas.MetricOfTable,
-                   metric_value: List):
-    step_size = int(metrics_helper.get_step_size(endTimestamp=data.endTimestamp, startTimestamp=data.startTimestamp,
-                                                 density=density, factor=1, decimal=True))
+                   view_type: schemas.MetricTimeseriesViewType, metric_type: schemas.MetricType,
+                   metric_of: schemas.MetricOfTable, metric_value: List):
+    step_size = int(metrics_helper.__get_step_size(endTimestamp=data.endTimestamp, startTimestamp=data.startTimestamp,
+                                                   density=density, factor=1, decimal=True))
     extra_event = None
     if metric_of == schemas.MetricOfTable.VISITED_URL:
         extra_event = "events.pages"
@@ -29,35 +189,39 @@ def search2_series(data: schemas.SessionsSearchPayloadSchema, project_id: int, d
     sessions = []
     with pg_client.PostgresClient() as cur:
         if metric_type == schemas.MetricType.TIMESERIES:
-            if metric_of == schemas.MetricOfTimeseries.SESSION_COUNT:
-                # main_query = cur.mogrify(f"""WITH full_sessions AS (SELECT DISTINCT ON(s.session_id) s.session_id, s.start_ts
-                main_query = cur.mogrify(f"""WITH full_sessions AS (SELECT s.session_id, s.start_ts
-                                                                {query_part})
-                                            SELECT generated_timestamp AS timestamp,
-                                                   COUNT(s)            AS count
-                                            FROM generate_series(%(startDate)s, %(endDate)s, %(step_size)s) AS generated_timestamp
-                                                     LEFT JOIN LATERAL (SELECT 1 AS s
-                                                                        FROM full_sessions
-                                                                        WHERE start_ts >= generated_timestamp
-                                                                          AND start_ts <= generated_timestamp + %(step_size)s) AS sessions ON (TRUE)
-                                            GROUP BY generated_timestamp
-                                            ORDER BY generated_timestamp;""", full_args)
-            elif metric_of == schemas.MetricOfTimeseries.USER_COUNT:
-                main_query = cur.mogrify(f"""WITH full_sessions AS (SELECT s.user_id, s.start_ts
+            if view_type == schemas.MetricTimeseriesViewType.LINE_CHART:
+                if metric_of == schemas.MetricOfTimeseries.SESSION_COUNT:
+                    # main_query = cur.mogrify(f"""WITH full_sessions AS (SELECT DISTINCT ON(s.session_id) s.session_id, s.start_ts
+                    main_query = cur.mogrify(f"""WITH full_sessions AS (SELECT s.session_id, s.start_ts
+                                                                    {query_part})
+                                                SELECT generated_timestamp AS timestamp,
+                                                       COUNT(s)            AS count
+                                                FROM generate_series(%(startDate)s, %(endDate)s, %(step_size)s) AS generated_timestamp
+                                                         LEFT JOIN LATERAL ( SELECT 1 AS s
+                                                                             FROM full_sessions
+                                                                             WHERE start_ts >= generated_timestamp
+                                                                               AND start_ts <= generated_timestamp + %(step_size)s) AS sessions ON (TRUE)
+                                                GROUP BY generated_timestamp
+                                                ORDER BY generated_timestamp;""", full_args)
+                elif metric_of == schemas.MetricOfTimeseries.USER_COUNT:
+                    main_query = cur.mogrify(f"""WITH full_sessions AS (SELECT s.user_id, s.start_ts
                                                                     {query_part}
                                                                     AND s.user_id IS NOT NULL
                                                                     AND s.user_id != '')
-                                            SELECT generated_timestamp AS timestamp,
-                                                   COUNT(s)            AS count
-                                            FROM generate_series(%(startDate)s, %(endDate)s, %(step_size)s) AS generated_timestamp
-                                                     LEFT JOIN LATERAL (SELECT DISTINCT user_id AS s
-                                                                        FROM full_sessions
-                                                                        WHERE start_ts >= generated_timestamp
-                                                                          AND start_ts <= generated_timestamp + %(step_size)s) AS sessions ON (TRUE)
-                                            GROUP BY generated_timestamp
-                                            ORDER BY generated_timestamp;""", full_args)
+                                                SELECT generated_timestamp AS timestamp,
+                                                       COUNT(s)            AS count
+                                                FROM generate_series(%(startDate)s, %(endDate)s, %(step_size)s) AS generated_timestamp
+                                                         LEFT JOIN LATERAL ( SELECT DISTINCT user_id AS s
+                                                                             FROM full_sessions
+                                                                             WHERE start_ts >= generated_timestamp
+                                                                               AND start_ts <= generated_timestamp + %(step_size)s) AS sessions ON (TRUE)
+                                                GROUP BY generated_timestamp
+                                                ORDER BY generated_timestamp;""", full_args)
+                else:
+                    raise Exception(f"Unsupported metricOf:{metric_of}")
             else:
-                raise Exception(f"Unsupported metricOf:{metric_of}")
+                main_query = cur.mogrify(f"""SELECT count(DISTINCT s.session_id) AS count
+                                            {query_part};""", full_args)
 
             logger.debug("--------------------")
             logger.debug(main_query)
@@ -71,8 +235,10 @@ def search2_series(data: schemas.SessionsSearchPayloadSchema, project_id: int, d
                 logger.warning(data.model_dump_json())
                 logger.warning("--------------------")
                 raise err
-            sessions = cur.fetchall()
-
+            if view_type == schemas.MetricTimeseriesViewType.LINE_CHART:
+                sessions = cur.fetchall()
+            else:
+                sessions = cur.fetchone()["count"]
         elif metric_type == schemas.MetricType.TABLE:
             if isinstance(metric_of, schemas.MetricOfTable):
                 main_col = "user_id"
@@ -133,8 +299,8 @@ def search2_series(data: schemas.SessionsSearchPayloadSchema, project_id: int, d
 def search2_table(data: schemas.SessionsSearchPayloadSchema, project_id: int, density: int,
                   metric_of: schemas.MetricOfTable, metric_value: List,
                   metric_format: Union[schemas.MetricExtendedFormatType, schemas.MetricExtendedFormatType]):
-    step_size = int(metrics_helper.get_step_size(endTimestamp=data.endTimestamp, startTimestamp=data.startTimestamp,
-                                                 density=density, factor=1, decimal=True))
+    step_size = int(metrics_helper.__get_step_size(endTimestamp=data.endTimestamp, startTimestamp=data.startTimestamp,
+                                                   density=density, factor=1, decimal=True))
     extra_event = None
     extra_conditions = None
     if metric_of == schemas.MetricOfTable.VISITED_URL:
@@ -148,7 +314,7 @@ def search2_table(data: schemas.SessionsSearchPayloadSchema, project_id: int, de
                         "isEvent": True,
                         "value": [],
                         "operator": e.operator,
-                        "filters": e.filters
+                        "filters": []
                     })
                 for v in e.value:
                     if v not in extra_conditions[e.operator].value:
@@ -165,7 +331,7 @@ def search2_table(data: schemas.SessionsSearchPayloadSchema, project_id: int, de
                         "isEvent": True,
                         "value": [],
                         "operator": e.operator,
-                        "filters": e.filters
+                        "filters": []
                     })
                 for v in e.value:
                     if v not in extra_conditions[e.operator].value:
@@ -302,6 +468,8 @@ def search_query_parts(data: schemas.SessionsSearchPayloadSchema, error_status,
     if len(data.filters) > 0:
         meta_keys = None
         for i, f in enumerate(data.filters):
+            if not isinstance(f.value, list):
+                f.value = [f.value]
             filter_type = f.type
             f.value = helper.values_for_operator(value=f.value, op=f.operator)
             f_k = f"f_value{i}"
@@ -989,7 +1157,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"""\
@@ -1002,6 +1170,69 @@ def search_query_parts(data: schemas.SessionsSearchPayloadSchema, error_status,
     return full_args, query_part
 
 
+def search_by_metadata(tenant_id, user_id, m_key, m_value, project_id=None):
+    if project_id is None:
+        all_projects = projects.get_projects(tenant_id=tenant_id)
+    else:
+        all_projects = [
+            projects.get_project(tenant_id=tenant_id, project_id=int(project_id), include_last_session=False,
+                                 include_gdpr=False)]
+
+    all_projects = {int(p["projectId"]): p["name"] for p in all_projects}
+    project_ids = list(all_projects.keys())
+
+    available_keys = metadata.get_keys_by_projects(project_ids)
+    for i in available_keys:
+        available_keys[i]["user_id"] = schemas.FilterType.USER_ID
+        available_keys[i]["user_anonymous_id"] = schemas.FilterType.USER_ANONYMOUS_ID
+    results = {}
+    for i in project_ids:
+        if m_key not in available_keys[i].values():
+            available_keys.pop(i)
+            results[i] = {"total": 0, "sessions": [], "missingMetadata": True}
+    project_ids = list(available_keys.keys())
+    if len(project_ids) > 0:
+        with pg_client.PostgresClient() as cur:
+            sub_queries = []
+            for i in project_ids:
+                col_name = list(available_keys[i].keys())[list(available_keys[i].values()).index(m_key)]
+                sub_queries.append(cur.mogrify(
+                    f"(SELECT COALESCE(COUNT(s.*)) AS count FROM public.sessions AS s WHERE s.project_id = %(id)s AND s.{col_name} = %(value)s) AS \"{i}\"",
+                    {"id": i, "value": m_value}).decode('UTF-8'))
+            query = f"""SELECT {", ".join(sub_queries)};"""
+            cur.execute(query=query)
+
+            rows = cur.fetchone()
+
+            sub_queries = []
+            for i in rows.keys():
+                results[i] = {"total": rows[i], "sessions": [], "missingMetadata": False, "name": all_projects[int(i)]}
+                if rows[i] > 0:
+                    col_name = list(available_keys[int(i)].keys())[list(available_keys[int(i)].values()).index(m_key)]
+                    sub_queries.append(
+                        cur.mogrify(
+                            f"""(
+                                    SELECT *
+                                    FROM (
+                                            SELECT DISTINCT ON(favorite_sessions.session_id, s.session_id) {SESSION_PROJECTION_COLS}
+                                            FROM public.sessions AS s LEFT JOIN (SELECT session_id
+                                                                                    FROM public.user_favorite_sessions
+                                                                                    WHERE user_favorite_sessions.user_id = %(userId)s
+                                                                                ) AS favorite_sessions USING (session_id)
+                                            WHERE s.project_id = %(id)s AND s.duration IS NOT NULL AND s.{col_name} = %(value)s
+                                        ) AS full_sessions
+                                    ORDER BY favorite DESC, issue_score DESC
+                                    LIMIT 10
+                                )""",
+                            {"id": i, "value": m_value, "userId": user_id}).decode('UTF-8'))
+            if len(sub_queries) > 0:
+                cur.execute("\nUNION\n".join(sub_queries))
+                rows = cur.fetchall()
+                for i in rows:
+                    results[str(i["project_id"])]["sessions"].append(helper.dict_to_camel_case(i))
+    return results
+
+
 def get_user_sessions(project_id, user_id, start_date, end_date):
     with pg_client.PostgresClient() as cur:
         constraints = ["s.project_id = %(projectId)s", "s.user_id = %(userId)s"]
@@ -1111,3 +1342,28 @@ def check_recording_status(project_id: int) -> dict:
         "recordingStatus": row["recording_status"],
         "sessionsCount": row["sessions_count"]
     }
+
+
+def search_sessions_by_ids(project_id: int, session_ids: list, sort_by: str = 'session_id',
+                           ascending: bool = False) -> dict:
+    if session_ids is None or len(session_ids) == 0:
+        return {"total": 0, "sessions": []}
+    with pg_client.PostgresClient() as cur:
+        meta_keys = metadata.get(project_id=project_id)
+        params = {"project_id": project_id, "session_ids": tuple(session_ids)}
+        order_direction = 'ASC' if ascending else 'DESC'
+        main_query = cur.mogrify(f"""SELECT {SESSION_PROJECTION_BASE_COLS}
+                                            {"," if len(meta_keys) > 0 else ""}{",".join([f'metadata_{m["index"]}' for m in meta_keys])}
+                                     FROM public.sessions AS s
+                                        WHERE project_id=%(project_id)s 
+                                            AND session_id IN %(session_ids)s
+                                     ORDER BY {sort_by} {order_direction};""", params)
+
+        cur.execute(main_query)
+        rows = cur.fetchall()
+        if len(meta_keys) > 0:
+            for s in rows:
+                s["metadata"] = {}
+                for m in meta_keys:
+                    s["metadata"][m["key"]] = s.pop(f'metadata_{m["index"]}')
+    return {"total": len(rows), "sessions": helper.list_to_camel_case(rows)}

api/chalicelib/core/sessions/sessions_assignments.py

@@ -1,11 +1,9 @@
-import json
-
 from decouple import config
-
-from chalicelib.core.issue_tracking import integrations_manager, base_issue
 from chalicelib.utils import helper
-from chalicelib.utils import pg_client
 from chalicelib.utils.TimeUTC import TimeUTC
+from chalicelib.utils import pg_client
+from chalicelib.core.issue_tracking import integrations_manager, integration_base_issue
+import json
 
 
 def __get_saved_data(project_id, session_id, issue_id, tool):
@@ -41,8 +39,8 @@ def create_new_assignment(tenant_id, project_id, session_id, creator_id, assigne
         issue = integration.issue_handler.create_new_assignment(title=title, assignee=assignee, description=description,
                                                                 issue_type=issue_type,
                                                                 integration_project_id=integration_project_id)
-    except base_issue.RequestException as e:
-        return base_issue.proxy_issues_handler(e)
+    except integration_base_issue.RequestException as e:
+        return integration_base_issue.proxy_issues_handler(e)
     if issue is None or "id" not in issue:
         return {"errors": ["something went wrong while creating the issue"]}
     with pg_client.PostgresClient() as cur:

api/chalicelib/core/sessions/sessions_devtool.py

@@ -1,10 +1,9 @@
 from decouple import config
 
-import schemas
 from chalicelib.utils.storage import StorageClient
 
 
-def get_devtools_keys(project_id, session_id):
+def __get_devtools_keys(project_id, session_id):
     params = {
         "sessionId": session_id,
         "projectId": project_id
@@ -14,9 +13,9 @@ def get_devtools_keys(project_id, session_id):
     ]
 
 
-def get_urls(session_id, project_id, context: schemas.CurrentContext, check_existence: bool = True):
+def get_urls(session_id, project_id, check_existence: bool = True):
     results = []
-    for k in get_devtools_keys(project_id=project_id, session_id=session_id):
+    for k in __get_devtools_keys(project_id=project_id, session_id=session_id):
         if check_existence and not StorageClient.exists(bucket=config("sessions_bucket"), key=k):
             continue
         results.append(StorageClient.get_presigned_url_for_sharing(
@@ -29,5 +28,5 @@ def get_urls(session_id, project_id, context: schemas.CurrentContext, check_exis
 
 def delete_mobs(project_id, session_ids):
     for session_id in session_ids:
-        for k in get_devtools_keys(project_id=project_id, session_id=session_id):
+        for k in __get_devtools_keys(project_id=project_id, session_id=session_id):
             StorageClient.tag_for_deletion(bucket=config("sessions_bucket"), key=k)

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

@@ -1 +0,0 @@
-from .sessions_devtool import *

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

@@ -1 +0,0 @@
-from .sessions_favorite import *

api/chalicelib/core/sessions/sessions_metas.py

@@ -1,81 +1,76 @@
-from functools import cache
-
 import schemas
 from chalicelib.core.autocomplete import autocomplete
 from chalicelib.utils.event_filter_definition import SupportedFilter
 
+SUPPORTED_TYPES = {
+    schemas.FilterType.USER_OS: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_OS),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_OS)),
+    schemas.FilterType.USER_BROWSER: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_BROWSER),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_BROWSER)),
+    schemas.FilterType.USER_DEVICE: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_DEVICE),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_DEVICE)),
+    schemas.FilterType.USER_COUNTRY: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_COUNTRY),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_COUNTRY)),
+    schemas.FilterType.USER_CITY: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_CITY),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_CITY)),
+    schemas.FilterType.USER_STATE: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_STATE),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_STATE)),
+    schemas.FilterType.USER_ID: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_ID),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_ID)),
+    schemas.FilterType.USER_ANONYMOUS_ID: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_ANONYMOUS_ID),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_ANONYMOUS_ID)),
+    schemas.FilterType.REV_ID: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.REV_ID),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.REV_ID)),
+    schemas.FilterType.REFERRER: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.REFERRER),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.REFERRER)),
+    schemas.FilterType.UTM_CAMPAIGN: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.UTM_CAMPAIGN),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.UTM_CAMPAIGN)),
+    schemas.FilterType.UTM_MEDIUM: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.UTM_MEDIUM),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.UTM_MEDIUM)),
+    schemas.FilterType.UTM_SOURCE: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.UTM_SOURCE),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.UTM_SOURCE)),
+    # Mobile
+    schemas.FilterType.USER_OS_MOBILE: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_OS_MOBILE),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_OS_MOBILE)),
+    schemas.FilterType.USER_DEVICE_MOBILE: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(
+            typename=schemas.FilterType.USER_DEVICE_MOBILE),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_DEVICE_MOBILE)),
+    schemas.FilterType.USER_COUNTRY_MOBILE: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_COUNTRY_MOBILE),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_COUNTRY_MOBILE)),
+    schemas.FilterType.USER_ID_MOBILE: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_ID_MOBILE),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_ID_MOBILE)),
+    schemas.FilterType.USER_ANONYMOUS_ID_MOBILE: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_ANONYMOUS_ID_MOBILE),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.USER_ANONYMOUS_ID_MOBILE)),
+    schemas.FilterType.REV_ID_MOBILE: SupportedFilter(
+        get=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.REV_ID_MOBILE),
+        query=autocomplete.__generic_autocomplete_metas(typename=schemas.FilterType.REV_ID_MOBILE)),
 
-@cache
-def supported_types():
-    return {
-        schemas.FilterType.USER_OS: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_OS),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_OS)),
-        schemas.FilterType.USER_BROWSER: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_BROWSER),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_BROWSER)),
-        schemas.FilterType.USER_DEVICE: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_DEVICE),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_DEVICE)),
-        schemas.FilterType.USER_COUNTRY: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_COUNTRY),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_COUNTRY)),
-        schemas.FilterType.USER_CITY: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_CITY),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_CITY)),
-        schemas.FilterType.USER_STATE: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_STATE),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_STATE)),
-        schemas.FilterType.USER_ID: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_ID),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_ID)),
-        schemas.FilterType.USER_ANONYMOUS_ID: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_ANONYMOUS_ID),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_ANONYMOUS_ID)),
-        schemas.FilterType.REV_ID: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.REV_ID),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.REV_ID)),
-        schemas.FilterType.REFERRER: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.REFERRER),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.REFERRER)),
-        schemas.FilterType.UTM_CAMPAIGN: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.UTM_CAMPAIGN),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.UTM_CAMPAIGN)),
-        schemas.FilterType.UTM_MEDIUM: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.UTM_MEDIUM),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.UTM_MEDIUM)),
-        schemas.FilterType.UTM_SOURCE: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.UTM_SOURCE),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.UTM_SOURCE)),
-        # Mobile
-        schemas.FilterType.USER_OS_MOBILE: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_OS_MOBILE),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_OS_MOBILE)),
-        schemas.FilterType.USER_DEVICE_MOBILE: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(
-                typename=schemas.FilterType.USER_DEVICE_MOBILE),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_DEVICE_MOBILE)),
-        schemas.FilterType.USER_COUNTRY_MOBILE: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_COUNTRY_MOBILE),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_COUNTRY_MOBILE)),
-        schemas.FilterType.USER_ID_MOBILE: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_ID_MOBILE),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_ID_MOBILE)),
-        schemas.FilterType.USER_ANONYMOUS_ID_MOBILE: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_ANONYMOUS_ID_MOBILE),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.USER_ANONYMOUS_ID_MOBILE)),
-        schemas.FilterType.REV_ID_MOBILE: SupportedFilter(
-            get=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.REV_ID_MOBILE),
-            query=autocomplete.generic_autocomplete_metas(typename=schemas.FilterType.REV_ID_MOBILE)),
-
-    }
+}
 
 
 def search(text: str, meta_type: schemas.FilterType, project_id: int):
     rows = []
-    if meta_type not in list(supported_types().keys()):
+    if meta_type not in list(SUPPORTED_TYPES.keys()):
         return {"errors": ["unsupported type"]}
-    rows += supported_types()[meta_type].get(project_id=project_id, text=text)
+    rows += SUPPORTED_TYPES[meta_type].get(project_id=project_id, text=text)
     # for IOS events autocomplete
     # if meta_type + "_IOS" in list(SUPPORTED_TYPES.keys()):
     #     rows += SUPPORTED_TYPES[meta_type + "_IOS"].get(project_id=project_id, text=text)

api/chalicelib/core/sessions/sessions_notes.py

@@ -30,7 +30,6 @@ def get_note(tenant_id, project_id, user_id, note_id, share=None):
         row = helper.dict_to_camel_case(row)
         if row:
             row["createdAt"] = TimeUTC.datetime_to_timestamp(row["createdAt"])
-            row["updatedAt"] = TimeUTC.datetime_to_timestamp(row["updatedAt"])
     return row
 
 
@@ -57,74 +56,41 @@ def get_session_notes(tenant_id, project_id, session_id, user_id):
 
 def get_all_notes_by_project_id(tenant_id, project_id, user_id, data: schemas.SearchNoteSchema):
     with pg_client.PostgresClient() as cur:
-        # base conditions
-        conditions = [
-            "sessions_notes.project_id = %(project_id)s",
-            "sessions_notes.deleted_at IS NULL"
-        ]
-        params = {"project_id": project_id, "user_id": user_id, "tenant_id": tenant_id}
-
-        # tag conditions
-        if data.tags:
-            tag_key = "tag_value"
+        conditions = ["sessions_notes.project_id = %(project_id)s", "sessions_notes.deleted_at IS NULL"]
+        extra_params = {}
+        if data.tags and len(data.tags) > 0:
+            k = "tag_value"
             conditions.append(
-                sh.multi_conditions(f"%({tag_key})s = sessions_notes.tag", data.tags, value_key=tag_key)
-            )
-            params.update(sh.multi_values(data.tags, value_key=tag_key))
-
-        # filter by ownership or shared status
+                sh.multi_conditions(f"%({k})s = sessions_notes.tag", data.tags, value_key=k))
+            extra_params = sh.multi_values(data.tags, value_key=k)
         if data.shared_only:
-            conditions.append("sessions_notes.is_public IS TRUE")
+            conditions.append("sessions_notes.is_public")
         elif data.mine_only:
             conditions.append("sessions_notes.user_id = %(user_id)s")
         else:
             conditions.append("(sessions_notes.user_id = %(user_id)s OR sessions_notes.is_public)")
-
-        # search condition
-        if data.search:
-            conditions.append("sessions_notes.message ILIKE %(search)s")
-            params["search"] = f"%{data.search}%"
-
-        query = f"""
-            SELECT 
-                COUNT(1) OVER () AS full_count, 
-                sessions_notes.*, 
-                users.name AS user_name
-            FROM 
-                sessions_notes 
-            INNER JOIN 
-                users USING (user_id)
-            WHERE 
-                {" AND ".join(conditions)}
-            ORDER BY 
-                created_at {data.order}
-            LIMIT 
-                %(limit)s OFFSET %(offset)s;
-        """
-        params.update({
-            "limit": data.limit,
-            "offset": data.limit * (data.page - 1)
-        })
-
-        query = cur.mogrify(query, params)
+        query = cur.mogrify(f"""SELECT COUNT(1) OVER () AS full_count, sessions_notes.*, users.name AS user_name
+                                FROM sessions_notes INNER JOIN users USING (user_id)
+                                WHERE {" AND ".join(conditions)}
+                                ORDER BY created_at {data.order}
+                                LIMIT {data.limit} OFFSET {data.limit * (data.page - 1)};""",
+                            {"project_id": project_id, "user_id": user_id, "tenant_id": tenant_id, **extra_params})
         logger.debug(query)
-        cur.execute(query)
+        cur.execute(query=query)
         rows = cur.fetchall()
-
         result = {"count": 0, "notes": helper.list_to_camel_case(rows)}
-        if rows:
+        if len(rows) > 0:
             result["count"] = rows[0]["fullCount"]
-            for row in rows:
-                row["createdAt"] = TimeUTC.datetime_to_timestamp(row["createdAt"])
-                row.pop("fullCount")
-
+        for row in rows:
+            row["createdAt"] = TimeUTC.datetime_to_timestamp(row["createdAt"])
+            row.pop("fullCount")
     return result
 
 
 def create(tenant_id, user_id, project_id, session_id, data: schemas.SessionNoteSchema):
     with pg_client.PostgresClient() as cur:
-        query = cur.mogrify(f"""INSERT INTO public.sessions_notes (message, user_id, tag, session_id, project_id, timestamp, is_public, thumbnail, start_at, end_at)
-                            VALUES (%(message)s, %(user_id)s, %(tag)s, %(session_id)s, %(project_id)s, %(timestamp)s, %(is_public)s, %(thumbnail)s, %(start_at)s, %(end_at)s)
+        query = cur.mogrify(f"""INSERT INTO public.sessions_notes (message, user_id, tag, session_id, project_id, timestamp, is_public)
+                            VALUES (%(message)s, %(user_id)s, %(tag)s, %(session_id)s, %(project_id)s, %(timestamp)s, %(is_public)s)
                             RETURNING *,(SELECT name FROM users WHERE users.user_id=%(user_id)s) AS user_name;""",
                             {"user_id": user_id, "project_id": project_id, "session_id": session_id,
                              **data.model_dump()})
@@ -145,8 +111,6 @@ def edit(tenant_id, user_id, project_id, note_id, data: schemas.SessionUpdateNot
         sub_query.append("is_public = %(is_public)s")
     if data.timestamp is not None:
         sub_query.append("timestamp = %(timestamp)s")
-
-    sub_query.append("updated_at = timezone('utc'::text, now())")
     with pg_client.PostgresClient() as cur:
         cur.execute(
             cur.mogrify(f"""UPDATE public.sessions_notes

api/chalicelib/core/sessions/sessions_replay.py

@@ -1,10 +1,9 @@
 import schemas
 from chalicelib.core import events, metadata, events_mobile, \
     issues, assist, canvas, user_testing
-from . import sessions_mobs, sessions_devtool
-from chalicelib.core.errors.modules import errors_helper
+from chalicelib.core.sessions import sessions_mobs, sessions_devtool
+from chalicelib.utils import errors_helper
 from chalicelib.utils import pg_client, helper
-from chalicelib.core.modules import MOB_KEY, get_file_key
 
 
 def __is_mobile_session(platform):
@@ -22,7 +21,6 @@ def __group_metadata(session, project_metadata):
 
 def get_pre_replay(project_id, session_id):
     return {
-        **get_file_key(project_id=project_id, session_id=session_id),
         'domURL': [sessions_mobs.get_first_url(project_id=project_id, session_id=session_id, check_existence=False)]}
 
 
@@ -44,7 +42,6 @@ def get_replay(project_id, session_id, context: schemas.CurrentContext, full_dat
             SELECT
                 s.*,
                 s.session_id::text AS session_id,
-                {MOB_KEY}
                 (SELECT project_key FROM public.projects WHERE project_id = %(project_id)s LIMIT 1) AS project_key
                 {"," if len(extra_query) > 0 else ""}{",".join(extra_query)}
                 {(",json_build_object(" + ",".join([f"'{m}',p.{m}" for m in metadata.column_names()]) + ") AS project_metadata") if group_metadata else ''}
@@ -66,7 +63,7 @@ def get_replay(project_id, session_id, context: schemas.CurrentContext, full_dat
                 else:
                     data['mobsUrl'] = sessions_mobs.get_urls_depercated(session_id=session_id, check_existence=False)
                     data['devtoolsURL'] = sessions_devtool.get_urls(session_id=session_id, project_id=project_id,
-                                                                    context=context, check_existence=False)
+                                                                    check_existence=False)
                     data['canvasURL'] = canvas.get_canvas_presigned_urls(session_id=session_id, project_id=project_id)
                     if user_testing.has_test_signals(session_id=session_id, project_id=project_id):
                         data['utxVideo'] = user_testing.get_ux_webcam_signed_url(session_id=session_id,

api/chalicelib/core/sessions/sessions_search.py

@@ -1,268 +0,0 @@
-import logging
-
-import schemas
-from chalicelib.core import metadata, projects
-from . import sessions_favorite, sessions_legacy
-from chalicelib.utils import pg_client, helper
-
-logger = logging.getLogger(__name__)
-
-SESSION_PROJECTION_BASE_COLS = """s.project_id,
-s.session_id::text AS session_id,
-s.user_uuid,
-s.user_id,
-s.user_os,
-s.user_browser,
-s.user_device,
-s.user_device_type,
-s.user_country,
-s.user_city,
-s.user_state,
-s.start_ts,
-s.duration,
-s.events_count,
-s.pages_count,
-s.errors_count,
-s.user_anonymous_id,
-s.platform,
-s.issue_score,
-s.timezone,
-to_jsonb(s.issue_types) AS issue_types """
-
-SESSION_PROJECTION_COLS = SESSION_PROJECTION_BASE_COLS + """,
-favorite_sessions.session_id NOTNULL            AS favorite,
-COALESCE((SELECT TRUE
- FROM public.user_viewed_sessions AS fs
- WHERE s.session_id = fs.session_id
-   AND fs.user_id = %(userId)s LIMIT 1), FALSE) AS viewed """
-
-
-# This function executes the query and return result
-def search_sessions(data: schemas.SessionsSearchPayloadSchema, project: schemas.ProjectContext,
-                    user_id, errors_only=False, error_status=schemas.ErrorStatus.ALL,
-                    count_only=False, issue=None, ids_only=False, platform="web"):
-    if data.bookmarked:
-        data.startTimestamp, data.endTimestamp = sessions_favorite.get_start_end_timestamp(project.project_id, user_id)
-    if data.startTimestamp is None:
-        logger.debug(f"No vault sessions found for project:{project.project_id}")
-        return {
-            'total': 0,
-            'sessions': [],
-            'src': 1
-        }
-    full_args, query_part = sessions_legacy.search_query_parts(data=data, error_status=error_status,
-                                                               errors_only=errors_only,
-                                                               favorite_only=data.bookmarked, issue=issue,
-                                                               project_id=project.project_id,
-                                                               user_id=user_id, platform=platform)
-    if data.limit is not None and data.page is not None:
-        full_args["sessions_limit"] = data.limit
-        full_args["sessions_limit_s"] = (data.page - 1) * data.limit
-        full_args["sessions_limit_e"] = data.page * data.limit
-    else:
-        full_args["sessions_limit"] = 200
-        full_args["sessions_limit_s"] = 0
-        full_args["sessions_limit_e"] = 200
-
-    meta_keys = []
-    with pg_client.PostgresClient() as cur:
-        if errors_only:
-            main_query = cur.mogrify(f"""SELECT DISTINCT er.error_id,
-                                         COALESCE((SELECT TRUE
-                                                     FROM public.user_viewed_errors AS ve
-                                                     WHERE er.error_id = ve.error_id
-                                                       AND ve.user_id = %(userId)s LIMIT 1), FALSE) AS viewed
-                                        {query_part};""", full_args)
-
-        elif count_only:
-            main_query = cur.mogrify(f"""SELECT COUNT(DISTINCT s.session_id) AS count_sessions, 
-                                                COUNT(DISTINCT s.user_uuid) AS count_users
-                                        {query_part};""", full_args)
-        elif data.group_by_user:
-            g_sort = "count(full_sessions)"
-            if data.order is None:
-                data.order = schemas.SortOrderType.DESC.value
-            else:
-                data.order = data.order
-            if data.sort is not None and data.sort != 'sessionsCount':
-                sort = helper.key_to_snake_case(data.sort)
-                g_sort = f"{'MIN' if data.order == schemas.SortOrderType.DESC else 'MAX'}({sort})"
-            else:
-                sort = 'start_ts'
-
-            meta_keys = metadata.get(project_id=project.project_id)
-            main_query = cur.mogrify(f"""SELECT COUNT(*) AS count,
-                                                COALESCE(JSONB_AGG(users_sessions) 
-                                                    FILTER (WHERE rn>%(sessions_limit_s)s AND rn<=%(sessions_limit_e)s), '[]'::JSONB) AS sessions
-                                        FROM (SELECT user_id,
-                                                 count(full_sessions)                                   AS user_sessions_count,
-                                                 jsonb_agg(full_sessions) FILTER (WHERE rn <= 1)        AS last_session,
-                                                 MIN(full_sessions.start_ts)                            AS first_session_ts,
-                                                 ROW_NUMBER() OVER (ORDER BY {g_sort} {data.order}) AS rn
-                                            FROM (SELECT *, ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY {sort} {data.order}) AS rn 
-                                                FROM (SELECT DISTINCT ON(s.session_id) {SESSION_PROJECTION_COLS} 
-                                                                    {"," if len(meta_keys) > 0 else ""}{",".join([f'metadata_{m["index"]}' for m in meta_keys])}
-                                                    {query_part}
-                                                    ) AS filtred_sessions
-                                                ) AS full_sessions
-                                                GROUP BY user_id
-                                            ) AS users_sessions;""",
-                                     full_args)
-        elif ids_only:
-            main_query = cur.mogrify(f"""SELECT DISTINCT ON(s.session_id) s.session_id
-                                             {query_part}
-                                             ORDER BY s.session_id desc
-                                             LIMIT %(sessions_limit)s OFFSET %(sessions_limit_s)s;""",
-                                     full_args)
-        else:
-            if data.order is None:
-                data.order = schemas.SortOrderType.DESC.value
-            else:
-                data.order = data.order
-            sort = 'session_id'
-            if data.sort is not None and data.sort != "session_id":
-                # sort += " " + data.order + "," + helper.key_to_snake_case(data.sort)
-                if data.sort == 'datetime':
-                    sort = 'start_ts'
-                else:
-                    sort = helper.key_to_snake_case(data.sort)
-
-            meta_keys = metadata.get(project_id=project.project_id)
-            main_query = cur.mogrify(f"""SELECT COUNT(full_sessions) AS count, 
-                                                COALESCE(JSONB_AGG(full_sessions) 
-                                                    FILTER (WHERE rn>%(sessions_limit_s)s AND rn<=%(sessions_limit_e)s), '[]'::JSONB) AS sessions
-                                            FROM (SELECT *, ROW_NUMBER() OVER (ORDER BY {sort} {data.order}, issue_score DESC) AS rn
-                                            FROM (SELECT DISTINCT ON(s.session_id) {SESSION_PROJECTION_COLS}
-                                                                {"," if len(meta_keys) > 0 else ""}{",".join([f'metadata_{m["index"]}' for m in meta_keys])}
-                                            {query_part}
-                                            ORDER BY s.session_id desc) AS filtred_sessions
-                                            ORDER BY {sort} {data.order}, issue_score DESC) AS full_sessions;""",
-                                     full_args)
-        logger.debug("--------------------")
-        logger.debug(main_query)
-        logger.debug("--------------------")
-        try:
-            cur.execute(main_query)
-            sessions = cur.fetchone()
-        except Exception as err:
-            logger.warning("--------- SESSIONS SEARCH QUERY EXCEPTION -----------")
-            logger.warning(main_query.decode('UTF-8'))
-            logger.warning("--------- PAYLOAD -----------")
-            logger.warning(data.model_dump_json())
-            logger.warning("--------------------")
-            raise err
-        if errors_only or ids_only:
-            return helper.list_to_camel_case(cur.fetchall())
-
-        if count_only:
-            return helper.dict_to_camel_case(sessions)
-
-        total = sessions["count"]
-        sessions = sessions["sessions"]
-
-    if data.group_by_user:
-        for i, s in enumerate(sessions):
-            sessions[i] = {**s.pop("last_session")[0], **s}
-            sessions[i].pop("rn")
-            sessions[i]["metadata"] = {k["key"]: sessions[i][f'metadata_{k["index"]}'] for k in meta_keys \
-                                       if sessions[i][f'metadata_{k["index"]}'] is not None}
-    else:
-        for i, s in enumerate(sessions):
-            sessions[i]["metadata"] = {k["key"]: sessions[i][f'metadata_{k["index"]}'] for k in meta_keys \
-                                       if sessions[i][f'metadata_{k["index"]}'] is not None}
-    # if not data.group_by_user and data.sort is not None and data.sort != "session_id":
-    #     sessions = sorted(sessions, key=lambda s: s[helper.key_to_snake_case(data.sort)],
-    #                       reverse=data.order.upper() == "DESC")
-    return {
-        'total': total,
-        'sessions': helper.list_to_camel_case(sessions),
-        'src': 1
-    }
-
-
-def search_by_metadata(tenant_id, user_id, m_key, m_value, project_id=None):
-    if project_id is None:
-        all_projects = projects.get_projects(tenant_id=tenant_id)
-    else:
-        all_projects = [
-            projects.get_project(tenant_id=tenant_id, project_id=int(project_id), include_last_session=False,
-                                 include_gdpr=False)]
-
-    all_projects = {int(p["projectId"]): p["name"] for p in all_projects}
-    project_ids = list(all_projects.keys())
-
-    available_keys = metadata.get_keys_by_projects(project_ids)
-    for i in available_keys:
-        available_keys[i]["user_id"] = schemas.FilterType.USER_ID
-        available_keys[i]["user_anonymous_id"] = schemas.FilterType.USER_ANONYMOUS_ID
-    results = {}
-    for i in project_ids:
-        if m_key not in available_keys[i].values():
-            available_keys.pop(i)
-            results[i] = {"total": 0, "sessions": [], "missingMetadata": True}
-    project_ids = list(available_keys.keys())
-    if len(project_ids) > 0:
-        with pg_client.PostgresClient() as cur:
-            sub_queries = []
-            for i in project_ids:
-                col_name = list(available_keys[i].keys())[list(available_keys[i].values()).index(m_key)]
-                sub_queries.append(cur.mogrify(
-                    f"(SELECT COALESCE(COUNT(s.*)) AS count FROM public.sessions AS s WHERE s.project_id = %(id)s AND s.{col_name} = %(value)s) AS \"{i}\"",
-                    {"id": i, "value": m_value}).decode('UTF-8'))
-            query = f"""SELECT {", ".join(sub_queries)};"""
-            cur.execute(query=query)
-
-            rows = cur.fetchone()
-
-            sub_queries = []
-            for i in rows.keys():
-                results[i] = {"total": rows[i], "sessions": [], "missingMetadata": False, "name": all_projects[int(i)]}
-                if rows[i] > 0:
-                    col_name = list(available_keys[int(i)].keys())[list(available_keys[int(i)].values()).index(m_key)]
-                    sub_queries.append(
-                        cur.mogrify(
-                            f"""(
-                                    SELECT *
-                                    FROM (
-                                            SELECT DISTINCT ON(favorite_sessions.session_id, s.session_id) {SESSION_PROJECTION_COLS}
-                                            FROM public.sessions AS s LEFT JOIN (SELECT session_id
-                                                                                    FROM public.user_favorite_sessions
-                                                                                    WHERE user_favorite_sessions.user_id = %(userId)s
-                                                                                ) AS favorite_sessions USING (session_id)
-                                            WHERE s.project_id = %(id)s AND s.duration IS NOT NULL AND s.{col_name} = %(value)s
-                                        ) AS full_sessions
-                                    ORDER BY favorite DESC, issue_score DESC
-                                    LIMIT 10
-                                )""",
-                            {"id": i, "value": m_value, "userId": user_id}).decode('UTF-8'))
-            if len(sub_queries) > 0:
-                cur.execute("\nUNION\n".join(sub_queries))
-                rows = cur.fetchall()
-                for i in rows:
-                    results[str(i["project_id"])]["sessions"].append(helper.dict_to_camel_case(i))
-    return results
-
-
-def search_sessions_by_ids(project_id: int, session_ids: list, sort_by: str = 'session_id',
-                           ascending: bool = False) -> dict:
-    if session_ids is None or len(session_ids) == 0:
-        return {"total": 0, "sessions": []}
-    with pg_client.PostgresClient() as cur:
-        meta_keys = metadata.get(project_id=project_id)
-        params = {"project_id": project_id, "session_ids": tuple(session_ids)}
-        order_direction = 'ASC' if ascending else 'DESC'
-        main_query = cur.mogrify(f"""SELECT {SESSION_PROJECTION_BASE_COLS}
-                                            {"," if len(meta_keys) > 0 else ""}{",".join([f'metadata_{m["index"]}' for m in meta_keys])}
-                                     FROM public.sessions AS s
-                                        WHERE project_id=%(project_id)s 
-                                            AND session_id IN %(session_ids)s
-                                     ORDER BY {sort_by} {order_direction};""", params)
-
-        cur.execute(main_query)
-        rows = cur.fetchall()
-        if len(meta_keys) > 0:
-            for s in rows:
-                s["metadata"] = {}
-                for m in meta_keys:
-                    s["metadata"][m["key"]] = s.pop(f'metadata_{m["index"]}')
-    return {"total": len(rows), "sessions": helper.list_to_camel_case(rows)}

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

@@ -1 +0,0 @@
-from .sessions_viewed import *

api/chalicelib/core/sessions/unprocessed_sessions.py

@@ -1,7 +1,6 @@
 import logging
 
-from chalicelib.core import assist
-from . import sessions
+from chalicelib.core import sessions, assist
 
 logger = logging.getLogger(__name__)
 

api/chalicelib/core/significance.py

@@ -1,16 +1,21 @@
 import logging
-import math
-import warnings
-from collections import defaultdict
-from typing import List
-
-from psycopg2.extras import RealDictRow
 
 import schemas
 from chalicelib.core import events, metadata
-from chalicelib.utils import pg_client, helper
 from chalicelib.utils import sql_helper as sh
 
+"""
+todo: remove LIMIT from the query
+"""
+
+from typing import List
+import math
+import warnings
+from collections import defaultdict
+
+from psycopg2.extras import RealDictRow
+from chalicelib.utils import pg_client, helper
+
 logger = logging.getLogger(__name__)
 SIGNIFICANCE_THRSH = 0.4
 # Taha: the value 24 was estimated in v1.15

api/chalicelib/core/sourcemaps.py

@@ -3,7 +3,7 @@ from urllib.parse import urlparse
 import requests
 from decouple import config
 
-from chalicelib.core.sourcemaps import sourcemaps_parser
+from chalicelib.core import sourcemaps_parser
 from chalicelib.utils.storage import StorageClient, generators
 
 

api/chalicelib/core/spot.py

@@ -18,7 +18,7 @@ def refresh_spot_jwt_iat_jti(user_id):
                             {"user_id": user_id})
         cur.execute(query)
         row = cur.fetchone()
-        return users.RefreshSpotJWTs(**row)
+        return row.get("spot_jwt_iat"), row.get("spot_jwt_refresh_jti"), row.get("spot_jwt_refresh_iat")
 
 
 def logout(user_id: int):
@@ -26,13 +26,13 @@ def logout(user_id: int):
 
 
 def refresh(user_id: int, tenant_id: int = -1) -> dict:
-    j = refresh_spot_jwt_iat_jti(user_id=user_id)
+    spot_jwt_iat, spot_jwt_r_jti, spot_jwt_r_iat = refresh_spot_jwt_iat_jti(user_id=user_id)
     return {
-        "jwt": authorizers.generate_jwt(user_id=user_id, tenant_id=tenant_id, iat=j.spot_jwt_iat,
+        "jwt": authorizers.generate_jwt(user_id=user_id, tenant_id=tenant_id, iat=spot_jwt_iat,
                                         aud=AUDIENCE, for_spot=True),
-        "refreshToken": authorizers.generate_jwt_refresh(user_id=user_id, tenant_id=tenant_id, iat=j.spot_jwt_refresh_iat,
-                                                         aud=AUDIENCE, jwt_jti=j.spot_jwt_refresh_jti, for_spot=True),
-        "refreshTokenMaxAge": config("JWT_SPOT_REFRESH_EXPIRATION", cast=int) - (j.spot_jwt_iat - j.spot_jwt_refresh_iat)
+        "refreshToken": authorizers.generate_jwt_refresh(user_id=user_id, tenant_id=tenant_id, iat=spot_jwt_r_iat,
+                                                         aud=AUDIENCE, jwt_jti=spot_jwt_r_jti, for_spot=True),
+        "refreshTokenMaxAge": config("JWT_SPOT_REFRESH_EXPIRATION", cast=int) - (spot_jwt_iat - spot_jwt_r_iat)
     }
 
 

api/chalicelib/core/usability_testing/service.py

@@ -1,7 +1,6 @@
 import logging
 
-from chalicelib.core import assist
-from chalicelib.core.sessions import sessions_search
+from chalicelib.core import sessions, assist
 from chalicelib.core.db_request_handler import DatabaseRequestHandler
 from chalicelib.core.usability_testing.schema import UTTestCreate, UTTestSearch, UTTestUpdate
 from chalicelib.utils.TimeUTC import TimeUTC
@@ -313,7 +312,7 @@ def ut_tests_sessions(project_id: int, test_id: int, page: int, limit: int, user
 
     session_ids = handler.fetchall()
     session_ids = [session['session_id'] for session in session_ids]
-    sessions_list = sessions_search.search_sessions_by_ids(project_id=project_id, session_ids=session_ids)
+    sessions_list = sessions.search_sessions_by_ids(project_id=project_id, session_ids=session_ids)
     sessions_list['page'] = page
 
     return sessions_list

api/chalicelib/core/users.py

@@ -1,14 +1,13 @@
 import json
 import secrets
-from typing import Optional
 
 from decouple import config
 from fastapi import BackgroundTasks
-from pydantic import BaseModel, model_validator
+from pydantic import BaseModel
 
 import schemas
-from chalicelib.core import authorizers
-from chalicelib.core import tenants, spot
+from chalicelib.core import authorizers, metadata
+from chalicelib.core import tenants, spot, scope
 from chalicelib.utils import email_helper
 from chalicelib.utils import helper
 from chalicelib.utils import pg_client
@@ -84,6 +83,7 @@ def restore_member(user_id, email, invitation_token, admin, name, owner=False):
                              "name": name, "invitation_token": invitation_token})
         cur.execute(query)
         result = cur.fetchone()
+        cur.execute(query)
         result["created_at"] = TimeUTC.datetime_to_timestamp(result["created_at"])
     return helper.dict_to_camel_case(result)
 
@@ -284,7 +284,7 @@ def edit_member(user_id_to_update, tenant_id, changes: schemas.EditMemberSchema,
     if editor_id != user_id_to_update:
         admin = get_user_role(tenant_id=tenant_id, user_id=editor_id)
         if not admin["superAdmin"] and not admin["admin"]:
-            return {"errors": ["unauthorized, you must have admin privileges"]}
+            return {"errors": ["unauthorized"]}
         if admin["admin"] and user["superAdmin"]:
             return {"errors": ["only the owner can edit his own details"]}
     else:
@@ -552,35 +552,14 @@ def refresh_auth_exists(user_id, jwt_jti=None):
     return r is not None
 
 
-class FullLoginJWTs(BaseModel):
+class ChangeJwt(BaseModel):
     jwt_iat: int
-    jwt_refresh_jti: str
+    jwt_refresh_jti: int
     jwt_refresh_iat: int
     spot_jwt_iat: int
-    spot_jwt_refresh_jti: str
+    spot_jwt_refresh_jti: int
     spot_jwt_refresh_iat: int
 
-    @model_validator(mode="before")
-    @classmethod
-    def _transform_data(cls, values):
-        if values.get("jwt_refresh_jti") is not None:
-            values["jwt_refresh_jti"] = str(values["jwt_refresh_jti"])
-        if values.get("spot_jwt_refresh_jti") is not None:
-            values["spot_jwt_refresh_jti"] = str(values["spot_jwt_refresh_jti"])
-        return values
-
-
-class RefreshLoginJWTs(FullLoginJWTs):
-    spot_jwt_iat: Optional[int] = None
-    spot_jwt_refresh_jti: Optional[str] = None
-    spot_jwt_refresh_iat: Optional[int] = None
-
-
-class RefreshSpotJWTs(FullLoginJWTs):
-    jwt_iat: Optional[int] = None
-    jwt_refresh_jti: Optional[str] = None
-    jwt_refresh_iat: Optional[int] = None
-
 
 def change_jwt_iat_jti(user_id):
     with pg_client.PostgresClient() as cur:
@@ -601,7 +580,7 @@ def change_jwt_iat_jti(user_id):
                             {"user_id": user_id})
         cur.execute(query)
         row = cur.fetchone()
-        return FullLoginJWTs(**row)
+        return ChangeJwt(**row)
 
 
 def refresh_jwt_iat_jti(user_id):
@@ -616,7 +595,7 @@ def refresh_jwt_iat_jti(user_id):
                             {"user_id": user_id})
         cur.execute(query)
         row = cur.fetchone()
-        return RefreshLoginJWTs(**row)
+        return row.get("jwt_iat"), row.get("jwt_refresh_jti"), row.get("jwt_refresh_iat")
 
 
 def authenticate(email, password, for_change_password=False) -> dict | bool | None:
@@ -648,12 +627,9 @@ def authenticate(email, password, for_change_password=False) -> dict | bool | No
         response = {
             "jwt": authorizers.generate_jwt(user_id=r['userId'], tenant_id=r['tenantId'], iat=j_r.jwt_iat,
                                             aud=AUDIENCE),
-            "refreshToken": authorizers.generate_jwt_refresh(user_id=r['userId'],
-                                                             tenant_id=r['tenantId'],
-                                                             iat=j_r.jwt_refresh_iat,
-                                                             aud=AUDIENCE,
-                                                             jwt_jti=j_r.jwt_refresh_jti,
-                                                             for_spot=False),
+            "refreshToken": authorizers.generate_jwt_refresh(user_id=r['userId'], tenant_id=r['tenantId'],
+                                                             iat=j_r.jwt_refresh_iat, aud=AUDIENCE,
+                                                             jwt_jti=j_r.jwt_refresh_jti),
             "refreshTokenMaxAge": config("JWT_REFRESH_EXPIRATION", cast=int),
             "email": email,
             "spotJwt": authorizers.generate_jwt(user_id=r['userId'], tenant_id=r['tenantId'],
@@ -684,13 +660,13 @@ def logout(user_id: int):
 
 
 def refresh(user_id: int, tenant_id: int = -1) -> dict:
-    j = refresh_jwt_iat_jti(user_id=user_id)
+    jwt_iat, jwt_r_jti, jwt_r_iat = refresh_jwt_iat_jti(user_id=user_id)
     return {
-        "jwt": authorizers.generate_jwt(user_id=user_id, tenant_id=tenant_id, iat=j.jwt_iat,
+        "jwt": authorizers.generate_jwt(user_id=user_id, tenant_id=tenant_id, iat=jwt_iat,
                                         aud=AUDIENCE),
-        "refreshToken": authorizers.generate_jwt_refresh(user_id=user_id, tenant_id=tenant_id, iat=j.jwt_refresh_iat,
-                                                         aud=AUDIENCE, jwt_jti=j.jwt_refresh_jti),
-        "refreshTokenMaxAge": config("JWT_REFRESH_EXPIRATION", cast=int) - (j.jwt_iat - j.jwt_refresh_iat),
+        "refreshToken": authorizers.generate_jwt_refresh(user_id=user_id, tenant_id=tenant_id, iat=jwt_r_iat,
+                                                         aud=AUDIENCE, jwt_jti=jwt_r_jti),
+        "refreshTokenMaxAge": config("JWT_REFRESH_EXPIRATION", cast=int) - (jwt_iat - jwt_r_iat)
     }
 
 

api/chalicelib/core/weekly_report.py

@@ -1,11 +1,7 @@
-import logging
-
 from chalicelib.utils import pg_client, helper, email_helper, smtp
 from chalicelib.utils.TimeUTC import TimeUTC
 from chalicelib.utils.helper import get_issue_title
 
-logger = logging.getLogger(__name__)
-
 LOWEST_BAR_VALUE = 3
 
 
@@ -34,7 +30,7 @@ def edit_config(user_id, weekly_report):
 
 def cron():
     if not smtp.has_smtp():
-        logger.info("!!! No SMTP configuration found, ignoring weekly report")
+        print("!!! No SMTP configuration found, ignoring weekly report")
         return
     _now = TimeUTC.now()
     with pg_client.PostgresClient(unlimited_query=True) as cur:
@@ -92,17 +88,17 @@ def cron():
                      ) AS month_1_issues ON (TRUE);"""), params)
         projects_data = cur.fetchall()
         _now2 = TimeUTC.now()
-        logger.debug(f">> Weekly report query: {_now2 - _now} ms")
+        print(f">> Weekly report query: {_now2 - _now} ms")
         _now = _now2
         emails_to_send = []
         for p in projects_data:
             params["project_id"] = p["project_id"]
-            logger.debug(f"checking {p['project_name']} : {p['project_id']}")
+            print(f"checking {p['project_name']} : {p['project_id']}")
             if len(p["emails"]) == 0 \
                     or p["this_week_issues_count"] + p["past_week_issues_count"] + p["past_month_issues_count"] == 0:
-                logger.debug('ignore')
+                print('ignore')
                 continue
-            logger.debug("valid")
+            print("valid")
             p["past_week_issues_evolution"] = helper.__decimal_limit(
                 helper.__progress(p["this_week_issues_count"], p["past_week_issues_count"]), 1)
             p["past_month_issues_evolution"] = helper.__decimal_limit(
@@ -125,7 +121,7 @@ def cron():
                 ORDER BY timestamp_i;""", params))
             days_partition = cur.fetchall()
             _now2 = TimeUTC.now()
-            logger.debug(f">> Weekly report s-query-1: {_now2 - _now} ms project_id: {p['project_id']}")
+            print(f">> Weekly report s-query-1: {_now2 - _now} ms project_id: {p['project_id']}")
             _now = _now2
             max_days_partition = max(x['issues_count'] for x in days_partition)
             for d in days_partition:
@@ -144,7 +140,7 @@ def cron():
             LIMIT 4;""", params))
             issues_by_type = cur.fetchall()
             _now2 = TimeUTC.now()
-            logger.debug(f">> Weekly report s-query-1: {_now2 - _now} ms project_id: {p['project_id']}")
+            print(f">> Weekly report s-query-1: {_now2 - _now} ms project_id: {p['project_id']}")
             _now = _now2
             max_issues_by_type = sum(i["count"] for i in issues_by_type)
             for i in issues_by_type:
@@ -176,7 +172,7 @@ def cron():
                 ORDER BY timestamp_i;""", params))
             issues_breakdown_by_day = cur.fetchall()
             _now2 = TimeUTC.now()
-            logger.debug(f">> Weekly report s-query-1: {_now2 - _now} ms project_id: {p['project_id']}")
+            print(f">> Weekly report s-query-1: {_now2 - _now} ms project_id: {p['project_id']}")
             _now = _now2
             for i in issues_breakdown_by_day:
                 i["sum"] = sum(x["count"] for x in i["partition"])
@@ -225,7 +221,7 @@ def cron():
                 ORDER BY issue_count DESC;""", params))
             issues_breakdown_list = cur.fetchall()
             _now2 = TimeUTC.now()
-            logger.debug(f">> Weekly report s-query-1: {_now2 - _now} ms project_id: {p['project_id']}")
+            print(f">> Weekly report s-query-1: {_now2 - _now} ms project_id: {p['project_id']}")
             _now = _now2
             if len(issues_breakdown_list) > 4:
                 others = {"type": "Others",
@@ -259,6 +255,6 @@ def cron():
                                        "issues_breakdown_by_day": issues_breakdown_by_day,
                                        "issues_breakdown_list": issues_breakdown_list
                                    }})
-        logger.info(f">>> Sending weekly report to {len(emails_to_send)} email-group")
+        print(f">>> Sending weekly report to {len(emails_to_send)} email-group")
         for e in emails_to_send:
             email_helper.weekly_report2(recipients=e["email"], data=e["data"])

api/chalicelib/utils/ch_client.py

@@ -41,7 +41,8 @@ class ClickHouseClient:
             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 EXCEPTION -----------")
+            logger.error(err)
             logger.error("--------- CH QUERY EXCEPTION -----------")
             logger.error(self.format(query=query, parameters=parameters)
                          .replace('\n', '\\n')

api/chalicelib/utils/ch_client_exp.py

@@ -6,6 +6,7 @@ from queue import Queue, Empty
 
 import clickhouse_connect
 from clickhouse_connect.driver.query import QueryContext
+from clickhouse_connect.driver.exceptions import DatabaseError
 from decouple import config
 
 logger = logging.getLogger(__name__)
@@ -31,13 +32,10 @@ if config("CH_COMPRESSION", cast=bool, default=True):
     extra_args["compression"] = "lz4"
 
 
-def transform_result(self, original_function):
+def transform_result(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]))
+        logger.info("Executing query on CH")
         result = original_function(*args, **kwargs)
         if isinstance(result, clickhouse_connect.driver.query.QueryResult):
             column_names = result.column_names
@@ -111,14 +109,14 @@ def make_pool():
         try:
             CH_pool.close_all()
         except Exception as error:
-            logger.error("Error while closing all connexions to CH", exc_info=error)
+            logger.error("Error while closing all connexions to CH", 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)
+        logger.error("Error while connecting to CH", error)
         if RETRY < RETRY_MAX:
             RETRY += 1
             logger.info(f"waiting for {RETRY_INTERVAL}s before retry n°{RETRY}")
@@ -133,27 +131,27 @@ class ClickHouseClient:
 
     def __init__(self, database=None):
         if self.__client is None:
-            if database is not None or not config('CH_POOL', cast=bool, default=True):
+            if database is None and config('CH_POOL', cast=bool, default=True):
+                self.__client = CH_pool.get_connection()
+            else:
                 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.execute = transform_result(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 format(self, query, *, parameters=None):
+        if parameters is None:
+            return query
+        return query % {
+            key: f"'{value}'" if isinstance(value, str) else value
+            for key, value in parameters.items()
+        }
 
     def __exit__(self, *args):
         if config('CH_POOL', cast=bool, default=True):
@@ -175,4 +173,4 @@ async def terminate():
             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)
+            logger.error("Error while closing all connexions to CH", error)