chore(version): update to version '1.0.4'

Make sure values return from pebble function are obfuscate
when return from the input validation endpoints.

Changes:
* UI: Don't send default input values when creating new execution

Fixes: #11681

.github/actions/plugins-list/action.yml

@@ -1,29 +0,0 @@
-name: 'Load Kestra Plugin List'
-description: 'Composite action to load list of plugins'
-inputs:
-  plugin-version:
-    description: "Kestra version"
-    default: 'LATEST'
-    required: true
-  plugin-file:
-    description: "File of the plugins"
-    default: './.plugins'
-    required: true
-outputs:
-  plugins:
-    description: "List of all Kestra plugins"
-    value: ${{ steps.plugins.outputs.plugins }}
-  repositories:
-    description: "List of all Kestra repositories of plugins"
-    value: ${{ steps.plugins.outputs.repositories }}
-runs:
-  using: composite
-  steps:
-    - name: Get Plugins List
-      id: plugins
-      shell: bash
-      run: |
-        PLUGINS=$([ -f ${{ inputs.plugin-file }} ] && cat ${{ inputs.plugin-file }} | grep "io\\.kestra\\." | sed -e '/#/s/^.//' | sed -e "s/LATEST/${{ inputs.plugin-version }}/g" | cut -d':' -f2- | xargs || echo '');
-        REPOSITORIES=$([ -f ${{ inputs.plugin-file }} ] && cat ${{ inputs.plugin-file }} | grep "io\\.kestra\\." | sed -e '/#/s/^.//' | cut -d':' -f1 | uniq | sort | xargs || echo '')
-        echo "plugins=$PLUGINS" >> $GITHUB_OUTPUT
-        echo "repositories=$REPOSITORIES" >> $GITHUB_OUTPUT

.github/actions/setup-vars/action.yml

@@ -1,20 +0,0 @@
-name: 'Setup vars'
-description: 'Composite action to setup common vars'
-outputs:
-  tag:
-    description: "Git tag"
-    value: ${{ steps.vars.outputs.tag }}
-  commit:
-    description: "Git commit"
-    value: ${{ steps.vars.outputs.commit }}
-runs:
-  using: composite
-  steps:
-    # Setup vars
-    - name: Set variables
-      id: vars
-      shell: bash
-      run: |
-        TAG=${GITHUB_REF#refs/*/}
-        echo "tag=${TAG}" >> $GITHUB_OUTPUT
-        echo "commit=$(git rev-parse --short "$GITHUB_SHA")" >> $GITHUB_OUTPUT

.github/workflows/auto-translate-ui-keys.yml

@@ -1,67 +0,0 @@
-name: Auto-Translate UI keys and create PR
-
-on:
-  schedule:
-    - cron: "0 9-21/3 * * *"  # Every 3 hours from 9 AM to 9 PM
-  workflow_dispatch:
-    inputs:
-      retranslate_modified_keys:
-        description: "Whether to re-translate modified keys even if they already have translations."
-        type: choice
-        options:
-          - "false"
-          - "true"
-        default: "false"
-        required: false
-
-jobs:
-  translations:
-    name: Translations
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    steps:
-        - uses: actions/checkout@v5
-          name: Checkout
-          with:
-            fetch-depth: 0
-
-        - name: Set up Python
-          uses: actions/setup-python@v6
-          with:
-            python-version: "3.x"
-
-        - name: Install Python dependencies
-          run: pip install gitpython openai
-
-        - name: Generate translations
-          run: python ui/src/translations/generate_translations.py ${{ github.event.inputs.retranslate_modified_keys }}
-          env:
-            OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-
-        - name: Set up Node
-          uses: actions/setup-node@v5
-          with:
-            node-version: "20.x"
-
-        - name: Set up Git
-          run: |
-            git config --global user.name "GitHub Action"
-            git config --global user.email "actions@github.com"
-
-        - name: Commit and create PR
-          env:
-            GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          run: |
-            BRANCH_NAME="chore/update-translations-$(date +%s)"
-            git checkout -b $BRANCH_NAME
-            git add ui/src/translations/*.json
-            if git diff --cached --quiet; then
-              echo "No changes to commit. Exiting with success."
-              exit 0
-            fi
-            git commit -m "chore(core): localize to languages other than english" -m "Extended localization support by adding translations for multiple languages using English as the base. This enhances accessibility and usability for non-English-speaking users while keeping English as the source reference."
-            git push -u origin $BRANCH_NAME || (git push origin --delete $BRANCH_NAME && git push -u origin $BRANCH_NAME)
-            gh pr create --title "Translations from en.json" --body $'This PR was created automatically by a GitHub Action.\n\nSomeone from the @kestra-io/frontend team needs to review and merge.' --base ${{ github.ref_name }} --head $BRANCH_NAME
-
-        - name: Check keys matching
-          run: node ui/src/translations/check.js

.github/workflows/codeql-analysis.yml

@@ -1,85 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-name: "CodeQL"
-
-on:
-  schedule:
-    - cron: '0 5 * * 1'
-
-  workflow_dispatch: {}
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-
-    strategy:
-      fail-fast: false
-      matrix:
-        # Override automatic language detection by changing the below list
-        # Supported options are ['csharp', 'cpp', 'go', 'java', 'javascript', 'python']
-        language: ['java', 'javascript']
-        # Learn more...
-        # https://docs.github.com/en/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#overriding-automatic-language-detection
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v5
-      with:
-        # We must fetch at least the immediate parents so that if this is
-        # a pull request then we can checkout the head.
-        fetch-depth: 2
-
-    # If this run was triggered by a pull request event, then checkout
-    # the head of the pull request instead of the merge commit.
-    - run: git checkout HEAD^2
-      if: ${{ github.event_name == 'pull_request' }}
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-        # queries: ./path/to/local/query, your-org/your-repo/queries@main
-
-    # Set up JDK
-    - name: Set up JDK
-      uses: actions/setup-java@v5
-      if: ${{ matrix.language == 'java' }}
-      with:
-        distribution: 'temurin'
-        java-version: 21
-
-    - name: Setup gradle
-      if: ${{ matrix.language == 'java' }}
-      uses: gradle/actions/setup-gradle@v4
-
-    - name: Build with Gradle
-      if: ${{ matrix.language == 'java' }}
-      run: ./gradlew testClasses -x :ui:assembleFrontend
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      if: ${{ matrix.language != 'java' }}
-      uses: github/codeql-action/autobuild@v3
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 https://git.io/JvXDl
-
-    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
-    #    and modify them (or add more) to build your code if your project
-    #    uses a compiled language
-
-    #- run: |
-    #   make bootstrap
-    #   make release
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3

.github/workflows/e2e.yml

@@ -1,86 +0,0 @@
-name: 'E2E tests revival'
-description: 'New E2E tests implementation started by Roman. Based on playwright in npm UI project, tests Kestra OSS develop docker image. These tests are written from zero, lets make them unflaky from the start!.'
-on:
-  schedule:
-    - cron: "0 * * * *"  # Every hour
-  workflow_call:
-    inputs:
-      noInputYet:
-        description: 'not input yet.'
-        required: false
-        type: string
-        default: "no input"
-  workflow_dispatch:
-    inputs:
-      noInputYet:
-        description: 'not input yet.'
-        required: false
-        type: string
-        default: "no input"
-jobs:
-  check:
-    timeout-minutes: 15
-    runs-on: ubuntu-latest
-    env:
-      GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
-    steps:
-      - name: Login to DockerHub
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ github.token }}
-
-      - name: Checkout kestra
-        uses: actions/checkout@v5
-        with:
-          path: kestra
-
-      # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
-        name: Setup - Build
-        id: build
-        with:
-          java-enabled: true
-          node-enabled: true
-          python-enabled: true
-
-      - name: Install Npm dependencies
-        run: |
-          cd kestra/ui
-          npm i
-          npx playwright install --with-deps chromium
-
-      - name: Run E2E Tests
-        run: |
-          cd kestra
-          sh build-and-start-e2e-tests.sh
-
-      - name: Upload Playwright Report as Github artifact
-        # 'With this report, you can analyze locally the results of the tests. see https://playwright.dev/docs/ci-intro#html-report'
-        uses: actions/upload-artifact@v4
-        if: ${{ !cancelled() }}
-        with:
-          name: playwright-report
-          path: kestra/ui/playwright-report/
-          retention-days: 7
-        # Allure check
-        # TODO I don't know what it should do
-#      - uses: rlespinasse/github-slug-action@v5
-#        name: Allure - Generate slug variables
-#
-#      - name: Allure - Publish report
-#        uses: andrcuns/allure-publish-action@v2.9.0
-#        if: always() && env.GOOGLE_SERVICE_ACCOUNT != ''
-#        continue-on-error: true
-#        env:
-#          GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_AUTH_TOKEN }}
-#          JAVA_HOME: /usr/lib/jvm/default-jvm/
-#        with:
-#          storageType: gcs
-#          resultsGlob: "**/build/allure-results"
-#          bucket: internal-kestra-host
-#          baseUrl: "https://internal.dev.kestra.io"
-#          prefix: ${{ format('{0}/{1}', github.repository, 'allure/java') }}
-#          copyLatest: true
-#          ignoreMissingResults: true

.github/workflows/gradle-release-plugins.yml

@@ -1,74 +0,0 @@
-name: Run Gradle Release for Kestra Plugins
-
-on:
-  workflow_dispatch:
-    inputs:
-      releaseVersion:
-        description: 'The release version (e.g., 0.21.0)'
-        required: true
-        type: string
-      nextVersion:
-        description: 'The next version (e.g., 0.22.0-SNAPSHOT)'
-        required: true
-        type: string
-      dryRun:
-        description: 'Use DRY_RUN mode'
-        required: false
-        default: 'false'
-jobs:
-  release:
-    name: Release plugins
-    runs-on: ubuntu-latest
-    steps:
-      # Checkout
-      - uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-
-      # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
-        id: build
-        with:
-          java-enabled: true
-          node-enabled: true
-          python-enabled: true
-
-      # Get Plugins List
-      - name: Get Plugins List
-        uses: ./.github/actions/plugins-list
-        id: plugins-list
-        with:
-          plugin-version: 'LATEST'
-
-      - name: 'Configure Git'
-        run: |
-          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
-          git config --global user.name "github-actions[bot]"
-
-      # Execute
-      - name: Run Gradle Release
-        if: ${{ github.event.inputs.dryRun == 'false' }}
-        env:
-          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
-        run: |
-          chmod +x ./dev-tools/release-plugins.sh;
-
-          ./dev-tools/release-plugins.sh \
-          --release-version=${{github.event.inputs.releaseVersion}} \
-          --next-version=${{github.event.inputs.nextVersion}} \
-          --yes \
-           ${{ steps.plugins-list.outputs.repositories }}
-
-      - name: Run Gradle Release (DRY_RUN)
-        if: ${{ github.event.inputs.dryRun == 'true' }}
-        env:
-          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
-        run: |
-          chmod +x ./dev-tools/release-plugins.sh;
-
-          ./dev-tools/release-plugins.sh \
-          --release-version=${{github.event.inputs.releaseVersion}} \
-          --next-version=${{github.event.inputs.nextVersion}} \
-          --dry-run \
-          --yes \
-          ${{ steps.plugins-list.outputs.repositories }}

.github/workflows/gradle-release.yml

@@ -1,84 +0,0 @@
-name: Run Gradle Release
-run-name: "Releasing Kestra ${{ github.event.inputs.releaseVersion }} 🚀"
-on:
-  workflow_dispatch:
-    inputs:
-      releaseVersion:
-        description: 'The release version (e.g., 0.21.0)'
-        required: true
-        type: string
-      nextVersion:
-        description: 'The next version (e.g., 0.22.0-SNAPSHOT)'
-        required: true
-        type: string
-env:
-  RELEASE_VERSION: "${{ github.event.inputs.releaseVersion }}"
-  NEXT_VERSION: "${{ github.event.inputs.nextVersion }}"
-jobs:
-  release:
-    name: Release Kestra
-    runs-on: ubuntu-latest
-    if: github.ref == 'refs/heads/develop'
-    steps:
-      # Checks
-      - name: Check Inputs
-        run: |
-          if ! [[ "$RELEASE_VERSION" =~ ^[0-9]+(\.[0-9]+)\.0$ ]]; then
-            echo "Invalid release version. Must match regex: ^[0-9]+(\.[0-9]+)\.0$"
-            exit 1
-          fi
-
-          if ! [[ "$NEXT_VERSION" =~ ^[0-9]+(\.[0-9]+)\.0-SNAPSHOT$ ]]; then
-            echo "Invalid next version. Must match regex: ^[0-9]+(\.[0-9]+)\.0-SNAPSHOT$"
-            exit 1;
-          fi
-      # Checkout
-      - uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-          path: kestra
-
-      # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
-        id: build
-        with:
-          java-enabled: true
-          node-enabled: true
-          python-enabled: true
-          caches-enabled: true
-
-      - name: Configure Git
-        run: |
-          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
-          git config --global user.name "github-actions[bot]"
-
-      # Execute
-      - name: Run Gradle Release
-        env:
-          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
-        run: |
-          # Extract the major and minor versions
-          BASE_VERSION=$(echo "$RELEASE_VERSION" | sed -E 's/^([0-9]+\.[0-9]+)\..*/\1/')
-          PUSH_RELEASE_BRANCH="releases/v${BASE_VERSION}.x"
-
-          cd kestra
-
-          # Create and push release branch
-          git checkout -b "$PUSH_RELEASE_BRANCH";
-          git push -u origin "$PUSH_RELEASE_BRANCH";
-
-          # Run gradle release
-          git checkout develop;
-
-          if [[ "$RELEASE_VERSION" == *"-SNAPSHOT" ]]; then
-            ./gradlew release -Prelease.useAutomaticVersion=true \
-            -Prelease.releaseVersion="${RELEASE_VERSION}" \
-            -Prelease.newVersion="${NEXT_VERSION}" \
-            -Prelease.pushReleaseVersionBranch="${PUSH_RELEASE_BRANCH}" \
-            -Prelease.failOnSnapshotDependencies=false
-          else
-            ./gradlew release -Prelease.useAutomaticVersion=true \
-            -Prelease.releaseVersion="${RELEASE_VERSION}" \
-            -Prelease.newVersion="${NEXT_VERSION}" \
-            -Prelease.pushReleaseVersionBranch="${PUSH_RELEASE_BRANCH}"
-          fi

.github/workflows/main-build.yml

@@ -1,6 +1,11 @@
 name: Main Workflow
 
 on:
+  push:
+    branches:
+      - releases/*
+      - develop
+
   workflow_dispatch:
     inputs:
       skip-test:
@@ -11,53 +16,58 @@ on:
         options:
           - "true"
           - "false"
-      plugin-version:
-          description: "plugins version"
-          required: false
-          type: string
-  push:
-    branches:
-      - master
-      - main
-      - releases/*
-      - develop
-    tags:
-      - v*
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}-main
   cancel-in-progress: true
 
 jobs:
-  tests:
-    name: Execute tests
-    uses: ./.github/workflows/workflow-test.yml
+  backend-tests:
+    name: Backend tests
     if: ${{ github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '' }}
-    with:
-      report-status: false
+    uses: kestra-io/actions/.github/workflows/kestra-oss-backend-tests.yml@main
+    secrets:
+      GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+      GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
 
-  release:
-    name: Release
-    needs: [tests]
-    if: "!failure() && !cancelled() && !startsWith(github.ref, 'refs/heads/releases')"
-    uses: ./.github/workflows/workflow-release.yml
+  frontend-tests:
+    name: Frontend tests
+    if: ${{ github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '' }}
+    uses: kestra-io/actions/.github/workflows/kestra-oss-frontend-tests.yml@main
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  publish-develop-docker:
+    name: Publish Docker
+    needs: [backend-tests, frontend-tests]
+    if: "!failure() && !cancelled() && github.ref == 'refs/heads/develop'"
+    uses: kestra-io/actions/.github/workflows/kestra-oss-publish-docker.yml@main
     with:
-        plugin-version: ${{ inputs.plugin-version != '' && inputs.plugin-version || (github.ref == 'refs/heads/develop' && 'LATEST-SNAPSHOT' || 'LATEST') }}
+      plugin-version: 'LATEST-SNAPSHOT'
     secrets:
       DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
       DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
+      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+
+
+  publish-develop-maven:
+    name: Publish develop Maven
+    needs: [ backend-tests, frontend-tests ]
+    if: "!failure() && !cancelled() && github.ref == 'refs/heads/develop'"
+    uses: kestra-io/actions/.github/workflows/kestra-oss-publish-maven.yml@main
+    secrets:
       SONATYPE_USER: ${{ secrets.SONATYPE_USER }}
       SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
       SONATYPE_GPG_KEYID: ${{ secrets.SONATYPE_GPG_KEYID }}
       SONATYPE_GPG_PASSWORD: ${{ secrets.SONATYPE_GPG_PASSWORD }}
       SONATYPE_GPG_FILE: ${{ secrets.SONATYPE_GPG_FILE }}
-      GH_PERSONAL_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}
-      SLACK_RELEASES_WEBHOOK_URL: ${{ secrets.SLACK_RELEASES_WEBHOOK_URL }}
 
   end:
     runs-on: ubuntu-latest
-    needs:
-      - release
+    needs: [publish-develop-docker, publish-develop-maven]
     if: always()
     steps:
       - name: Trigger EE Workflow

.github/workflows/pre-release.yml

@@ -0,0 +1,49 @@
+name: Pre Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+jobs:
+  build-artifacts:
+    name: Build Artifacts
+    uses: kestra-io/actions/.github/workflows/kestra-oss-build-artifacts.yml@main
+
+  backend-tests:
+    name: Backend tests
+    uses: kestra-io/actions/.github/workflows/kestra-oss-backend-tests.yml@main
+    secrets:
+      GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+      GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
+
+  frontend-tests:
+    name: Frontend tests
+    uses: kestra-io/actions/.github/workflows/kestra-oss-frontend-tests.yml@main
+    secrets:
+      GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  publish-maven:
+    name: Publish Maven
+    needs: [ backend-tests, frontend-tests ]
+    if: "!failure() && !cancelled()"
+    uses: kestra-io/actions/.github/workflows/kestra-oss-publish-maven.yml@main
+    secrets:
+      SONATYPE_USER: ${{ secrets.SONATYPE_USER }}
+      SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
+      SONATYPE_GPG_KEYID: ${{ secrets.SONATYPE_GPG_KEYID }}
+      SONATYPE_GPG_PASSWORD: ${{ secrets.SONATYPE_GPG_PASSWORD }}
+      SONATYPE_GPG_FILE: ${{ secrets.SONATYPE_GPG_FILE }}
+
+  publish-github:
+    name: Github Release
+    needs: [build-artifacts, backend-tests, frontend-tests]
+    if: "!failure() && !cancelled()"
+    uses: kestra-io/actions/.github/workflows/kestra-oss-publish-github.yml@main
+    secrets:
+      GH_PERSONAL_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}
+      SLACK_RELEASES_WEBHOOK_URL: ${{ secrets.SLACK_RELEASES_WEBHOOK_URL }}

.github/workflows/pull-request-cleanup.yml

@@ -3,7 +3,7 @@ name: Pull Request - Delete Docker
 on:
   pull_request:
     types: [closed]
-
+# TODO import a reusable one
 jobs:
   publish:
     name: Pull Request - Delete Docker

.github/workflows/pull-request.yml

@@ -2,18 +2,12 @@ name: Pull Request Workflow
 
 on:
   pull_request:
-    branches:
-      - develop
-      - releases/*
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref_name }}-pr
   cancel-in-progress: true
 
 jobs:
-  # ********************************************************************************************************************
-  # File changes detection
-  # ********************************************************************************************************************
   file-changes:
     if: ${{ github.event.pull_request.draft == false }}
     name: File changes detection
@@ -34,14 +28,11 @@ jobs:
               - '!{ui,.github}/**'
           token: ${{ secrets.GITHUB_TOKEN }}
 
-  # ********************************************************************************************************************
-  # Tests
-  # ********************************************************************************************************************
   frontend:
     name: Frontend - Tests
     needs: [file-changes]
     if: "needs.file-changes.outputs.ui == 'true'"
-    uses: ./.github/workflows/workflow-frontend-test.yml
+    uses: kestra-io/actions/.github/workflows/kestra-oss-frontend-tests.yml@main
     secrets:
       GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
@@ -50,7 +41,7 @@ jobs:
     name: Backend - Tests
     needs: file-changes
     if: "needs.file-changes.outputs.backend == 'true'"
-    uses: ./.github/workflows/workflow-backend-test.yml
+    uses: kestra-io/actions/.github/workflows/kestra-oss-backend-tests.yml@main
     secrets:
       GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
@@ -59,5 +50,8 @@ jobs:
 
   e2e-tests:
     name: E2E - Tests
-    uses: ./.github/workflows/e2e.yml
+    uses: kestra-io/actions/.github/workflows/kestra-oss-e2e-tests.yml@main
 
+  generate-pull-request-docker-image:
+    name: Generate PR docker image
+    uses: kestra-io/actions/.github/workflows/kestra-oss-pullrequest-publish-docker.yml@main

.github/workflows/release-docker.yml

@@ -0,0 +1,34 @@
+name: Publish docker
+
+on:
+  workflow_dispatch:
+    inputs:
+      retag-latest:
+        description: 'Retag latest Docker images'
+        required: true
+        type: boolean
+        default: false
+      retag-lts:
+        description: 'Retag LTS Docker images'
+        required: true
+        type: boolean
+        default: false
+      plugin-version:
+        description: 'Plugin version'
+        required: false
+        type: string
+        default: "LATEST"
+
+jobs:
+  publish-docker:
+    name: Publish Docker
+    if: startsWith(github.ref, 'refs/tags/v')
+    uses: kestra-io/actions/.github/workflows/kestra-oss-publish-docker.yml@main
+    with:
+      plugin-version: ${{ inputs.plugin-version }}
+      retag-latest: ${{ inputs.retag-latest }}
+      retag-lts: ${{ inputs.retag-lts }}
+    secrets:
+      DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+      DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
+      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}

.github/workflows/setversion-tag-plugins.yml

@@ -1,60 +0,0 @@
-name: Set Version and Tag Plugins
-
-on:
-  workflow_dispatch:
-    inputs:
-      releaseVersion:
-        description: 'The release version (e.g., 0.21.0)'
-        required: true
-        type: string
-      dryRun:
-        description: 'Use DRY_RUN mode'
-        required: false
-        default: 'false'
-jobs:
-  tag:
-    name: Release plugins
-    runs-on: ubuntu-latest
-    steps:
-      # Checkout
-      - uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-
-      # Get Plugins List
-      - name: Get Plugins List
-        uses: ./.github/actions/plugins-list
-        id: plugins-list
-        with:
-          plugin-version: 'LATEST'
-
-      - name: 'Configure Git'
-        run: |
-          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
-          git config --global user.name "github-actions[bot]"
-
-      # Execute
-      - name: Set Version and Tag Plugins
-        if: ${{ github.event.inputs.dryRun == 'false' }}
-        env:
-          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
-        run: |
-          chmod +x ./dev-tools/setversion-tag-plugins.sh;
-          
-          ./dev-tools/setversion-tag-plugins.sh \
-          --release-version=${{github.event.inputs.releaseVersion}} \
-          --yes \
-           ${{ steps.plugins-list.outputs.repositories }}
-
-      - name: Set Version and Tag Plugins (DRY_RUN)
-        if: ${{ github.event.inputs.dryRun == 'true' }}
-        env:
-          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
-        run: |
-          chmod +x ./dev-tools/setversion-tag-plugins.sh;
-          
-          ./dev-tools/setversion-tag-plugins.sh \
-          --release-version=${{github.event.inputs.releaseVersion}} \
-          --dry-run \
-          --yes \
-          ${{ steps.plugins-list.outputs.repositories }}

.github/workflows/setversion-tag.yml

@@ -1,60 +0,0 @@
-name: Set Version and Tag
-run-name: "Set version and Tag Kestra to ${{ github.event.inputs.releaseVersion }} 🚀"
-on:
-  workflow_dispatch:
-    inputs:
-      releaseVersion:
-        description: 'The release version (e.g., 0.21.1)'
-        required: true
-        type: string
-env:
-  RELEASE_VERSION: "${{ github.event.inputs.releaseVersion }}"
-jobs:
-  release:
-    name: Release Kestra
-    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/heads/releases/v')
-    steps:
-      # Checks
-      - name: Check Inputs
-        run: |
-          if ! [[ "$RELEASE_VERSION" =~ ^[0-9]+(\.[0-9]+)(\.[0-9]+)(-rc[0-9])?(-SNAPSHOT)?$ ]]; then
-            echo "Invalid release version. Must match regex: ^[0-9]+(\.[0-9]+)(\.[0-9]+)-(rc[0-9])?(-SNAPSHOT)?$"
-            exit 1
-          fi
-
-          # Extract the major and minor versions
-          BASE_VERSION=$(echo "$RELEASE_VERSION" | sed -E 's/^([0-9]+\.[0-9]+)\..*/\1/')
-          RELEASE_BRANCH="refs/heads/releases/v${BASE_VERSION}.x"
-
-          CURRENT_BRANCH="$GITHUB_REF"
-          if ! [[ "$CURRENT_BRANCH" == "$RELEASE_BRANCH" ]]; then
-            echo "Invalid release branch. Expected $RELEASE_BRANCH, was $CURRENT_BRANCH"
-            exit 1
-          fi
-
-      # Checkout
-      - name: Checkout
-        uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-          token: ${{ secrets.GH_PERSONAL_TOKEN }}
-
-      # Configure
-      - name: Git - Configure
-        run: |
-          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
-          git config --global user.name "github-actions[bot]"
-
-      # Execute
-      - name: Run Gradle Release
-        env:
-          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
-        run: |
-          # Update version
-          sed -i "s/^version=.*/version=$RELEASE_VERSION/" ./gradle.properties
-          git add ./gradle.properties
-          git commit -m"chore(version): update to version '$RELEASE_VERSION'"
-          git push
-          git tag -a "v$RELEASE_VERSION" -m"v$RELEASE_VERSION"
-          git push --tags

.github/workflows/vulnerabilities-check.yml

@@ -22,12 +22,11 @@ jobs:
           fetch-depth: 0
 
       # Setup build
-      - uses: ./actions/.github/actions/setup-build
+      - uses: kestra-io/actions/composite/setup-build@main
         id: build
         with:
           java-enabled: true
           node-enabled: true
-          caches-enabled: true
 
       # Npm
       - name: Npm - Install
@@ -49,77 +48,3 @@ jobs:
         with:
           name: dependency-check-report
           path: build/reports/dependency-check-report.html
-
-  develop-image-check:
-    name: Image Check (develop)
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      security-events: write
-      actions: read
-    steps:
-      # Checkout
-      - uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-
-      # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
-        id: build
-        with:
-          java-enabled: false
-          node-enabled: false
-          caches-enabled: true
-
-      # Run Trivy image scan for Docker vulnerabilities, see https://github.com/aquasecurity/trivy-action
-      - name: Docker Vulnerabilities Check
-        uses: aquasecurity/trivy-action@0.33.1
-        with:
-          image-ref: kestra/kestra:develop
-          format: 'template'
-          template: '@/contrib/sarif.tpl'
-          severity: 'CRITICAL,HIGH'
-          output: 'trivy-results.sarif'
-          skip-dirs: /app/plugins
-
-      - name: Upload Trivy scan results to GitHub Security tab
-        uses: github/codeql-action/upload-sarif@v3
-        with:
-          sarif_file: 'trivy-results.sarif'
-          category: docker-
-
-  latest-image-check:
-    name: Image Check (latest)
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      security-events: write
-      actions: read
-    steps:
-      # Checkout
-      - uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-
-      # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
-        id: build
-        with:
-          java-enabled: false
-          node-enabled: false
-
-      # Run Trivy image scan for Docker vulnerabilities, see https://github.com/aquasecurity/trivy-action
-      - name: Docker Vulnerabilities Check
-        uses: aquasecurity/trivy-action@0.33.1
-        with:
-          image-ref: kestra/kestra:latest
-          format: table
-          skip-dirs: /app/plugins
-          scanners: vuln
-          severity: 'CRITICAL,HIGH'
-          output: 'trivy-results.sarif'
-
-      - name: Upload Trivy scan results to GitHub Security tab
-        uses: github/codeql-action/upload-sarif@v3
-        with:
-          sarif_file: 'trivy-results.sarif'

.github/workflows/workflow-backend-test.yml

@@ -1,74 +0,0 @@
-name: Backend - Tests
-
-on:
-  workflow_call:
-    secrets:
-      GITHUB_AUTH_TOKEN:
-        description: "The GitHub Token."
-        required: true
-      CODECOV_TOKEN:
-        description: 'Codecov Token'
-        required: true
-      SONAR_TOKEN:
-        description: 'Sonar Token'
-        required: true
-      GOOGLE_SERVICE_ACCOUNT:
-        description: 'Google Service Account'
-        required: true
-
-permissions:
-  contents: write
-  checks: write
-  actions: read
-  pull-requests: write
-
-jobs:
-  test:
-    name: Backend - Tests
-    runs-on: ubuntu-latest
-    env:
-      GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
-      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
-    steps:
-      - uses: actions/checkout@v5
-        name: Checkout - Current ref
-        with:
-          fetch-depth: 0
-
-      # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
-        name: Setup - Build
-        id: build
-        with:
-          java-enabled: true
-          node-enabled: true
-          python-enabled: true
-
-      # Services
-      - name: Setup - Start docker compose
-        shell: bash
-        run: docker compose -f docker-compose-ci.yml up -d
-
-      # Gradle check
-      - name: Gradle - Build
-        if: ${{ github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '' }}
-        env:
-          GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
-        shell: bash
-        run: |
-          echo $GOOGLE_SERVICE_ACCOUNT | base64 -d > ~/.gcp-service-account.json
-          export GOOGLE_APPLICATION_CREDENTIALS=$HOME/.gcp-service-account.json
-          ./gradlew check javadoc --parallel
-
-      - name: comment PR with test report
-        if: ${{ !cancelled() && github.event_name == 'pull_request' }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_AUTH_TOKEN }}
-        run: npx --yes @kestra-io/kestra-devtools generateTestReportSummary --only-errors --ci $(pwd)
-
-      # Report Java
-      - name: Report - Java
-        uses: kestra-io/actions/composite/report-java@main
-        if: ${{ !cancelled() }}
-        with:
-          secrets: ${{ toJSON(secrets) }}

.github/workflows/workflow-build-artifacts.yml

@@ -1,80 +0,0 @@
-name: Build Artifacts
-
-on:
-  workflow_call: {}
-
-jobs:
-  build:
-    name: Build - Artifacts
-    runs-on: ubuntu-latest
-    outputs:
-        docker-tag: ${{ steps.vars.outputs.tag }}
-        docker-artifact-name: ${{ steps.vars.outputs.artifact }}
-        plugins: ${{ steps.plugins.outputs.plugins }}
-    env:
-      PLUGIN_VERSION: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
-    steps:
-      - name: Checkout - Current ref
-        uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-
-      # Npm
-      - name: Setup - Npm install
-        shell: bash
-        working-directory: ui
-        run: npm ci
-
-      # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
-        name: Setup - Build
-        id: build
-        with:
-          java-enabled: true
-          node-enabled: true
-
-      # Get Plugins List
-      - name: Plugins - Get List
-        uses: ./.github/actions/plugins-list
-        if: "!startsWith(github.ref, 'refs/tags/v')"
-        id: plugins-list
-        with:
-          plugin-version: ${{ env.PLUGIN_VERSION }}
-
-      # Set Plugins List
-      - name: Plugins - Set List
-        id: plugins
-        if: "!startsWith(github.ref, 'refs/tags/v')"
-        shell: bash
-        run: |
-          PLUGINS="${{ steps.plugins-list.outputs.plugins }}"
-          TAG=${GITHUB_REF#refs/*/}
-          if [[ $TAG = "master" || $TAG == v* ]]; then
-            echo "plugins=$PLUGINS" >> $GITHUB_OUTPUT
-          else
-            echo "plugins=--repositories=https://central.sonatype.com/repository/maven-snapshots/ $PLUGINS" >> $GITHUB_OUTPUT
-          fi
-
-      # Build
-      - name: Gradle - Build
-        shell: bash
-        run: |
-          ./gradlew executableJar
-
-      - name: Artifacts - Copy exe to image
-        shell: bash
-        run: |
-          cp build/executable/* docker/app/kestra && chmod +x docker/app/kestra
-
-      # Upload artifacts
-      - name: Artifacts - Upload JAR
-        uses: actions/upload-artifact@v4
-        with:
-          name: jar
-          path: build/libs/
-
-      - name: Artifacts - Upload Executable
-        uses: actions/upload-artifact@v4
-        with:
-          name: exe
-          path: build/executable/

.github/workflows/workflow-frontend-test.yml

@@ -1,70 +0,0 @@
-name: Frontend - Tests
-
-on:
-  workflow_call:
-    secrets:
-      GITHUB_AUTH_TOKEN:
-        description: "The GitHub Token."
-        required: true
-      CODECOV_TOKEN:
-        description: 'Codecov Token'
-        required: true
-
-env:
-  # to save corepack from itself
-  COREPACK_INTEGRITY_KEYS: 0
-
-jobs:
-  test:
-    name: Frontend - Tests
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Cache Node Modules
-        id: cache-node-modules
-        uses: actions/cache@v4
-        with:
-          path: |
-            ui/node_modules
-          key: modules-${{ hashFiles('ui/package-lock.json') }}
-
-      - name: Cache Playwright Binaries
-        id: cache-playwright
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cache/ms-playwright
-          key: playwright-${{ hashFiles('ui/package-lock.json') }}
-
-      - name: Npm - install
-        if: steps.cache-node-modules.outputs.cache-hit != 'true'
-        working-directory: ui
-        run: npm ci
-
-      - name: Npm - lint
-        uses: reviewdog/action-eslint@v1
-        with:
-          github_token: ${{ secrets.GITHUB_AUTH_TOKEN }}
-          reporter: github-pr-review
-          workdir: ui
-
-      - name: Npm - Run build
-        working-directory: ui
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-        run: npm run build
-
-      - name: Run front-end unit tests
-        working-directory: ui
-        run: npm run test:unit -- --coverage
-
-      - name: Storybook - Install Playwright
-        working-directory: ui
-        if: steps.cache-playwright.outputs.cache-hit != 'true'
-        run: npx playwright install --with-deps
-
-      - name: Run storybook component tests
-        working-directory: ui
-        run: npm run test:storybook -- --coverage

.github/workflows/workflow-github-release.yml

@@ -1,79 +0,0 @@
-name: Github - Release
-
-on:
-  workflow_dispatch:
-  workflow_call:
-    secrets:
-      GH_PERSONAL_TOKEN:
-        description: "The Github personal token."
-        required: true
-      SLACK_RELEASES_WEBHOOK_URL:
-        description: "The Slack webhook URL."
-        required: true
-
-
-
-jobs:
-  publish:
-    name: Github - Release
-    runs-on: ubuntu-latest
-    steps:
-      # Check out
-      - name: Checkout - Repository
-        uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-          submodules: true
-
-
-      # Download Exec
-      # Must be done after checkout actions
-      - name: Artifacts - Download executable
-        uses: actions/download-artifact@v5
-        if: startsWith(github.ref, 'refs/tags/v')
-        with:
-          name: exe
-          path: build/executable
-
-      - name: Check if current tag is latest
-        id: is_latest
-        run: |
-          latest_tag=$(git tag | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' | sed 's/^v//' | sort -V | tail -n1)
-          current_tag="${GITHUB_REF_NAME#v}"
-          if [ "$current_tag" = "$latest_tag" ]; then
-          echo "latest=true" >> $GITHUB_OUTPUT
-          else
-          echo "latest=false" >> $GITHUB_OUTPUT
-          fi
-        env:
-          GITHUB_REF_NAME: ${{ github.ref_name }}
-
-      # GitHub Release
-      - name: Create GitHub release
-        uses: kestra-io/actions/composite/github-release@main
-        if: ${{ startsWith(github.ref, 'refs/tags/v') }}
-        env:
-          MAKE_LATEST: ${{ steps.is_latest.outputs.latest }}
-          GITHUB_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}
-          SLACK_RELEASES_WEBHOOK_URL: ${{ secrets.SLACK_RELEASES_WEBHOOK_URL }}
-
-      # Trigger gha workflow to bump helm chart version
-      - name: GitHub - Trigger the Helm chart version bump
-        uses: peter-evans/repository-dispatch@v3
-        with:
-          token: ${{ secrets.GH_PERSONAL_TOKEN }}
-          repository: kestra-io/helm-charts
-          event-type: update-helm-chart-version
-          client-payload: |-
-            {
-              "new_version": "${{ github.ref_name }}",
-              "github_repository": "${{ github.repository }}",
-              "github_actor": "${{ github.actor }}"
-            }
-
-      - name: Merge Release Notes
-        if: ${{ startsWith(github.ref, 'refs/tags/v') }}
-        uses: kestra-io/actions/composite/github-release-note-merge@main
-        env:
-            GITHUB_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}
-            RELEASE_TAG: ${{ github.ref_name }}

.github/workflows/workflow-publish-docker.yml

@@ -1,208 +0,0 @@
-name: Create Docker images on Release
-
-on:
-  workflow_dispatch:
-    inputs:
-      retag-latest:
-        description: 'Retag latest Docker images'
-        required: true
-        type: choice
-        default: "false"
-        options:
-          - "true"
-          - "false"
-      retag-lts:
-        description: 'Retag LTS Docker images'
-        required: true
-        type: choice
-        default: "false"
-        options:
-          - "true"
-          - "false"
-      release-tag:
-        description: 'Kestra Release Tag (by default, deduced with the ref)'
-        required: false
-        type: string
-      plugin-version:
-        description: 'Plugin version'
-        required: false
-        type: string
-        default: "LATEST"
-      force-download-artifact:
-        description: 'Force download artifact'
-        required: false
-        type: choice
-        default: "true"
-        options:
-          - "true"
-          - "false"
-  workflow_call:
-    inputs:
-      plugin-version:
-        description: "Plugin version"
-        default: 'LATEST'
-        required: false
-        type: string
-      force-download-artifact:
-        description: 'Force download artifact'
-        required: false
-        type: string
-        default: "true"
-    secrets:
-      DOCKERHUB_USERNAME:
-        description: "The Dockerhub username."
-        required: true
-      DOCKERHUB_PASSWORD:
-        description: "The Dockerhub password."
-        required: true
-
-env:
-  PLUGIN_VERSION: ${{ inputs.plugin-version != null && inputs.plugin-version || 'LATEST' }}
-jobs:
-  plugins:
-    name: List Plugins
-    runs-on: ubuntu-latest
-    outputs:
-      plugins: ${{ steps.plugins.outputs.plugins }}
-    steps:
-      # Checkout
-      - uses: actions/checkout@v5
-
-      # Get Plugins List
-      - name: Get Plugins List
-        uses: ./.github/actions/plugins-list
-        id: plugins
-        with: # remap LATEST-SNAPSHOT to LATEST
-          plugin-version: ${{ env.PLUGIN_VERSION == 'LATEST-SNAPSHOT' && 'LATEST' || env.PLUGIN_VERSION }}
-
-  # ********************************************************************************************************************
-  # Build
-  # ********************************************************************************************************************
-  build-artifacts:
-    name: Build Artifacts
-    if: ${{ inputs.force-download-artifact == 'true' }}
-    uses: ./.github/workflows/workflow-build-artifacts.yml
-
-  docker:
-    name: Publish Docker
-    needs: [ plugins, build-artifacts ]
-    if: always()
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        image:
-          - name: "-no-plugins"
-            plugins: ""
-            packages: jattach
-            python-libs: ""
-          - name: ""
-            plugins: ${{needs.plugins.outputs.plugins}}
-            packages: python3 python-is-python3 python3-pip curl jattach
-            python-libs: kestra
-    steps:
-      - uses: actions/checkout@v5
-
-      # Vars
-      - name: Set image name
-        id: vars
-        run: |
-          if [[ "${{ inputs.release-tag }}" == "" ]]; then
-            TAG=${GITHUB_REF#refs/*/}
-            echo "tag=${TAG}" >> $GITHUB_OUTPUT
-          else
-            TAG="${{ inputs.release-tag }}"
-            echo "tag=${TAG}" >> $GITHUB_OUTPUT
-          fi
-
-          if [[ $GITHUB_REF == refs/tags/* ]]; then
-            if [[ $TAG =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-              # this will remove the patch version number
-              MINOR_SEMVER=${TAG%.*}
-              echo "minor_semver=${MINOR_SEMVER}" >> $GITHUB_OUTPUT
-            else
-              echo "Tag '$TAG' is not a valid semver (vMAJOR.MINOR.PATCH), skipping minor_semver"
-            fi
-          fi
-
-          if [[ "${{ env.PLUGIN_VERSION }}" == *"-SNAPSHOT" ]]; then
-            echo "plugins=--repositories=https://central.sonatype.com/repository/maven-snapshots/ ${{ matrix.image.plugins }}" >> $GITHUB_OUTPUT;
-          else
-            echo "plugins=${{ matrix.image.plugins }}" >> $GITHUB_OUTPUT
-          fi
-
-      # Download executable from artifact
-      - name: Artifacts - Download executable
-        uses: actions/download-artifact@v5
-        with:
-          name: exe
-          path: build/executable
-
-      - name: Copy exe to image
-        run: |
-          cp build/executable/* docker/app/kestra && chmod +x docker/app/kestra
-
-      # Docker setup
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-
-      - name: Docker - Fix Qemu
-        shell: bash
-        run: |
-          docker run --rm --privileged multiarch/qemu-user-static --reset -p yes -c yes
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      # Docker Login
-      - name: Login to DockerHub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_PASSWORD }}
-
-      # Docker Build and push
-      - name: Push to Docker Hub
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          push: true
-          tags: ${{ format('kestra/kestra:{0}{1}', steps.vars.outputs.tag, matrix.image.name) }}
-          platforms: linux/amd64,linux/arm64
-          build-args: |
-            KESTRA_PLUGINS=${{ steps.vars.outputs.plugins }}
-            APT_PACKAGES=${{ matrix.image.packages }}
-            PYTHON_LIBRARIES=${{ matrix.image.python-libs }}
-
-      - name: Install regctl
-        if: startsWith(github.ref, 'refs/tags/v')
-        uses: regclient/actions/regctl-installer@main
-
-      - name: Retag to minor semver version
-        if: startsWith(github.ref, 'refs/tags/v') && steps.vars.outputs.minor_semver != ''
-        run: |
-          regctl image copy ${{ format('kestra/kestra:{0}{1}', steps.vars.outputs.tag, matrix.image.name) }} ${{ format('kestra/kestra:{0}{1}', steps.vars.outputs.minor_semver, matrix.image.name) }}
-
-      - name: Retag to latest
-        if: startsWith(github.ref, 'refs/tags/v') && inputs.retag-latest == 'true'
-        run: |
-          regctl image copy ${{ format('kestra/kestra:{0}{1}', steps.vars.outputs.tag, matrix.image.name) }} ${{ format('kestra/kestra:latest{0}', matrix.image.name) }}
-
-      - name: Retag to LTS
-        if: startsWith(github.ref, 'refs/tags/v') && inputs.retag-lts == 'true'
-        run: |
-          regctl image copy ${{ format('kestra/kestra:{0}{1}', steps.vars.outputs.tag, matrix.image.name) }} ${{ format('kestra/kestra:latest-lts{0}', matrix.image.name) }}
-
-  end:
-    runs-on: ubuntu-latest
-    needs:
-      - docker
-    if: always()
-    env:
-      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
-    steps:
-      - name: Slack notification
-        if: ${{ failure() && env.SLACK_WEBHOOK_URL != 0 }}
-        uses: kestra-io/actions/composite/slack-status@main
-        with:
-          webhook-url: ${{ secrets.SLACK_WEBHOOK_URL }}
-

.github/workflows/workflow-publish-maven.yml

@@ -1,57 +0,0 @@
-name: Publish - Maven
-
-on:
-  workflow_call:
-    secrets:
-      SONATYPE_USER:
-        description: "The Sonatype username."
-        required: true
-      SONATYPE_PASSWORD:
-        description: "The Sonatype password."
-        required: true
-      SONATYPE_GPG_KEYID:
-        description: "The Sonatype GPG key id."
-        required: true
-      SONATYPE_GPG_PASSWORD:
-        description: "The Sonatype GPG password."
-        required: true
-      SONATYPE_GPG_FILE:
-        description: "The Sonatype GPG file."
-        required: true
-
-jobs:
-  publish:
-    name: Publish - Maven
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout - Current ref
-        uses: actions/checkout@v5
-
-      # Setup build
-      - name: Setup - Build
-        uses: kestra-io/actions/composite/setup-build@main
-        id: build
-        with:
-          java-enabled: true
-          node-enabled: true
-
-      # Publish
-      - name: Publish - Release package to Maven Central
-        shell: bash
-        env:
-          ORG_GRADLE_PROJECT_mavenCentralUsername: ${{ secrets.SONATYPE_USER }}
-          ORG_GRADLE_PROJECT_mavenCentralPassword: ${{ secrets.SONATYPE_PASSWORD }}
-          SONATYPE_GPG_KEYID: ${{ secrets.SONATYPE_GPG_KEYID }}
-          SONATYPE_GPG_PASSWORD: ${{ secrets.SONATYPE_GPG_PASSWORD }}
-          SONATYPE_GPG_FILE: ${{ secrets.SONATYPE_GPG_FILE}}
-        run: |
-          mkdir -p ~/.gradle/
-          echo "signing.keyId=${SONATYPE_GPG_KEYID}" > ~/.gradle/gradle.properties
-          echo "signing.password=${SONATYPE_GPG_PASSWORD}" >> ~/.gradle/gradle.properties
-          echo "signing.secretKeyRingFile=${HOME}/.gradle/secring.gpg" >> ~/.gradle/gradle.properties
-          echo ${SONATYPE_GPG_FILE} | base64 -d > ~/.gradle/secring.gpg
-          ./gradlew publishToMavenCentral
-
-      # Gradle dependency
-      - name: Java - Gradle dependency graph
-        uses: gradle/actions/dependency-submission@v4

.github/workflows/workflow-pullrequest-publish-docker.yml

@@ -1,78 +0,0 @@
-name: Pull Request - Publish Docker
-
-on:
-  pull_request:
-    branches:
-      - develop
-
-jobs:
-  build-artifacts:
-    name: Build Artifacts
-    if: github.repository == 'kestra-io/kestra' # prevent running on forks
-    uses: ./.github/workflows/workflow-build-artifacts.yml
-
-  publish:
-    name: Publish Docker
-    if: github.repository == 'kestra-io/kestra' # prevent running on forks
-    runs-on: ubuntu-latest
-    needs: build-artifacts
-    env:
-      GITHUB_IMAGE_PATH: "ghcr.io/kestra-io/kestra-pr"
-    steps:
-      - name: Checkout - Current ref
-        uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-
-      # Docker setup
-      - name: Docker - Setup QEMU
-        uses: docker/setup-qemu-action@v3
-
-      - name: Docker - Setup Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      # Docker Login
-      - name: Login to GHCR
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      # Build Docker Image
-      - name: Artifacts - Download executable
-        uses: actions/download-artifact@v5
-        with:
-          name: exe
-          path: build/executable
-
-      - name: Docker - Copy exe to image
-        shell: bash
-        run: |
-          cp build/executable/* docker/app/kestra && chmod +x docker/app/kestra
-
-      - name: Docker - Build image
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: ./Dockerfile.pr
-          push: true
-          tags: ${{ env.GITHUB_IMAGE_PATH }}:${{ github.event.pull_request.number }}
-          platforms: linux/amd64,linux/arm64
-
-      # Add comment on pull request
-      - name: Add comment to PR
-        uses: actions/github-script@v8
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            await github.rest.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: `**🐋 Docker image**: \`${{ env.GITHUB_IMAGE_PATH }}:${{ github.event.pull_request.number }}\`\n` +
-                `\n` +
-                `\`\`\`bash\n` +
-                `docker run --pull=always --rm -it -p 8080:8080 --user=root -v /var/run/docker.sock:/var/run/docker.sock -v /tmp:/tmp ${{ env.GITHUB_IMAGE_PATH }}:${{ github.event.pull_request.number }} server local\n` +
-                `\`\`\``
-            })

.github/workflows/workflow-release.yml

@@ -1,85 +0,0 @@
-name: Release
-
-on:
-  workflow_dispatch:
-    inputs:
-      plugin-version:
-        description: "plugins version"
-        default: 'LATEST'
-        required: false
-        type: string
-      publish-docker:
-        description: "Publish Docker image"
-        default: 'false'
-        required: false
-        type: string
-  workflow_call:
-    inputs:
-      plugin-version:
-        description: "plugins version"
-        default: 'LATEST'
-        required: false
-        type: string
-    secrets:
-      DOCKERHUB_USERNAME:
-        description: "The Dockerhub username."
-        required: true
-      DOCKERHUB_PASSWORD:
-        description: "The Dockerhub password."
-        required: true
-      SONATYPE_USER:
-        description: "The Sonatype username."
-        required: true
-      SONATYPE_PASSWORD:
-        description: "The Sonatype password."
-        required: true
-      SONATYPE_GPG_KEYID:
-        description: "The Sonatype GPG key id."
-        required: true
-      SONATYPE_GPG_PASSWORD:
-        description: "The Sonatype GPG password."
-        required: true
-      SONATYPE_GPG_FILE:
-        description: "The Sonatype GPG file."
-        required: true
-      GH_PERSONAL_TOKEN:
-        description: "GH personnal Token."
-        required: true
-      SLACK_RELEASES_WEBHOOK_URL:
-        description: "Slack webhook for releases channel."
-        required: true
-jobs:
-  build-artifacts:
-    name: Build - Artifacts
-    uses: ./.github/workflows/workflow-build-artifacts.yml
-
-  Docker:
-    name: Publish Docker
-    needs: build-artifacts
-    uses: ./.github/workflows/workflow-publish-docker.yml
-    if: github.ref == 'refs/heads/develop' || inputs.publish-docker == 'true'
-    with:
-      force-download-artifact: 'false'
-      plugin-version: ${{ inputs.plugin-version != null && inputs.plugin-version || 'LATEST' }}
-    secrets:
-      DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-      DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
-
-  Maven:
-    name: Publish Maven
-    uses: ./.github/workflows/workflow-publish-maven.yml
-    secrets:
-      SONATYPE_USER: ${{ secrets.SONATYPE_USER }}
-      SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
-      SONATYPE_GPG_KEYID: ${{ secrets.SONATYPE_GPG_KEYID }}
-      SONATYPE_GPG_PASSWORD: ${{ secrets.SONATYPE_GPG_PASSWORD }}
-      SONATYPE_GPG_FILE: ${{ secrets.SONATYPE_GPG_FILE }}
-
-  Github:
-    name: Github Release
-    needs: build-artifacts
-    if: startsWith(github.ref, 'refs/tags/v')
-    uses: ./.github/workflows/workflow-github-release.yml
-    secrets:
-      GH_PERSONAL_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}
-      SLACK_RELEASES_WEBHOOK_URL: ${{ secrets.SLACK_RELEASES_WEBHOOK_URL }}

.github/workflows/workflow-test.yml

@@ -1,95 +0,0 @@
-name: Tests
-
-on:
-  schedule:
-    - cron: '0 4 * * 1,2,3,4,5'
-  workflow_call:
-    inputs:
-      report-status:
-        description: "Report status of the jobs in outputs"
-        type: string
-        required: false
-        default: false
-    outputs:
-      frontend_status:
-        description: "Status of the frontend job"
-        value: ${{ jobs.set-frontend-status.outputs.frontend_status }}
-      backend_status:
-        description: "Status of the backend job"
-        value: ${{ jobs.set-backend-status.outputs.backend_status }}
-
-jobs:
-  file-changes:
-    name: File changes detection
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    outputs:
-      ui: ${{ steps.changes.outputs.ui }}
-      backend: ${{ steps.changes.outputs.backend }}
-    steps:
-      - uses: actions/checkout@v5
-        if: "!startsWith(github.ref, 'refs/tags/v')"
-      - uses: dorny/paths-filter@v3
-        if: "!startsWith(github.ref, 'refs/tags/v')"
-        id: changes
-        with:
-          filters: |
-            ui:
-              - 'ui/**'
-            backend:
-              - '!{ui,.github}/**'
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-  frontend:
-    name: Frontend - Tests
-    needs: file-changes
-    if: "needs.file-changes.outputs.ui == 'true' || startsWith(github.ref, 'refs/tags/v')"
-    uses: ./.github/workflows/workflow-frontend-test.yml
-    secrets:
-      GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-
-
-  backend:
-    name: Backend - Tests
-    needs: file-changes
-    if: "needs.file-changes.outputs.backend == 'true' || startsWith(github.ref, 'refs/tags/v')"
-    uses: ./.github/workflows/workflow-backend-test.yml
-    secrets:
-      GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
-      GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
-
-  # Output every job status
-  # To be used in other workflows
-  report-status:
-    name: Report Status
-    runs-on: ubuntu-latest
-    needs: [ frontend, backend ]
-    if: always() && (inputs.report-status == 'true')
-    outputs:
-      frontend_status: ${{ steps.set-frontend-status.outputs.frontend_status }}
-      backend_status: ${{ steps.set-backend-status.outputs.backend_status }}
-    steps:
-      - id: set-frontend-status
-        name: Set frontend job status
-        run: echo "::set-output name=frontend_status::${{ needs.frontend.result }}"
-
-      - id: set-backend-status
-        name: Set backend job status
-        run: echo "::set-output name=backend_status::${{ needs.backend.result }}"
-
-  notify:
-    name: Notify - Slack
-    runs-on: ubuntu-latest
-    needs: [ frontend, backend ]
-    steps:
-      - name: Notify failed CI
-        if: |
-          always() &&
-            (needs.frontend.result != 'success' || needs.backend.result != 'success') &&
-            (github.ref == 'refs/heads/master' || github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop')
-        uses: kestra-io/actions/composite/slack-status@main
-        with:
-          webhook-url: ${{ secrets.SLACK_WEBHOOK_URL }}

README.md

@@ -33,10 +33,10 @@
 
 <p align="center">
     <a href="https://go.kestra.io/video/product-overview" target="_blank">
-        <img src="https://kestra.io/startvideo.png" alt="Get started in 3 minutes with Kestra" width="640px" />
+        <img src="https://kestra.io/startvideo.png" alt="Get started in 4 minutes with Kestra" width="640px" />
     </a>
 </p>
-<p align="center" style="color:grey;"><i>Click on the image to learn how to get started with Kestra in 3 minutes.</i></p>
+<p align="center" style="color:grey;"><i>Click on the image to learn how to get started with Kestra in 4 minutes.</i></p>
 
 
 ## 🌟 What is Kestra?

build.gradle

@@ -32,12 +32,12 @@ plugins {
 
     // release
     id 'net.researchgate.release' version '3.1.0'
-    id "com.gorylenko.gradle-git-properties" version "2.5.3"
+    id "com.gorylenko.gradle-git-properties" version "2.5.2"
     id 'signing'
     id "com.vanniktech.maven.publish" version "0.34.0"
 
     // OWASP dependency check
-    id "org.owasp.dependencycheck" version "12.1.5" apply false
+    id "org.owasp.dependencycheck" version "12.1.3" apply false
 }
 
 idea {
@@ -168,9 +168,8 @@ allprojects {
 /**********************************************************************************************************************\
  * Test
  **********************************************************************************************************************/
-subprojects {subProj ->
-
-    if (subProj.name != 'platform' && subProj.name != 'jmh-benchmarks') {
+subprojects {
+    if (it.name != 'platform' && it.name != 'jmh-benchmarks') {
         apply plugin: "com.adarshr.test-logger"
 
         java {
@@ -208,13 +207,6 @@ subprojects {subProj ->
 
         test {
             useJUnitPlatform()
-            reports {
-                junitXml.required = true
-                junitXml.outputPerTestCase = true
-                junitXml.mergeReruns = true
-                junitXml.includeSystemErrLog = true;
-                junitXml.outputLocation = layout.buildDirectory.dir("test-results/test")
-            }
 
             // set Xmx for test workers
             maxHeapSize = '4g'
@@ -230,15 +222,6 @@ subprojects {subProj ->
             environment 'SECRET_PASSWORD', "cGFzc3dvcmQ="
             environment 'ENV_TEST1', "true"
             environment 'ENV_TEST2', "Pass by env"
-
-
-            if (subProj.name == 'core' || subProj.name == 'jdbc-h2' || subProj.name == 'jdbc-mysql' || subProj.name == 'jdbc-postgres') {
-                // JUnit 5 parallel settings
-                systemProperty 'junit.jupiter.execution.parallel.enabled', 'true'
-                systemProperty 'junit.jupiter.execution.parallel.mode.default', 'concurrent'
-                systemProperty 'junit.jupiter.execution.parallel.mode.classes.default', 'same_thread'
-                systemProperty 'junit.jupiter.execution.parallel.config.strategy', 'dynamic'
-            }
         }
 
         testlogger {

cli/build.gradle

@@ -40,6 +40,5 @@ dependencies {
     implementation project(":worker")
 
     //test
-    testImplementation project(':tests')
     testImplementation "org.wiremock:wiremock-jetty12"
 }

cli/src/main/java/io/kestra/cli/App.java

@@ -49,7 +49,7 @@ import java.util.concurrent.Callable;
 @Introspected
 public class App implements Callable<Integer> {
     public static void main(String[] args) {
-        execute(App.class, new String [] { Environment.CLI }, args);
+        execute(App.class, args);
     }
 
     @Override
@@ -57,13 +57,13 @@ public class App implements Callable<Integer> {
         return PicocliRunner.call(App.class, "--help");
     }
 
-    protected static void execute(Class<?> cls, String[] environments, String... args) {
+    protected static void execute(Class<?> cls, String... args) {
         // Log Bridge
         SLF4JBridgeHandler.removeHandlersForRootLogger();
         SLF4JBridgeHandler.install();
 
         // Init ApplicationContext
-        ApplicationContext applicationContext = App.applicationContext(cls, environments, args);
+        ApplicationContext applicationContext = App.applicationContext(cls, args);
 
         // Call Picocli command
         int exitCode = 0;
@@ -80,7 +80,6 @@ public class App implements Callable<Integer> {
         System.exit(Objects.requireNonNullElse(exitCode, 0));
     }
 
-
     /**
      * Create an {@link ApplicationContext} with additional properties based on configuration files (--config) and
      * forced Properties from current command.
@@ -89,13 +88,12 @@ public class App implements Callable<Integer> {
      * @return the application context created
      */
     protected static ApplicationContext applicationContext(Class<?> mainClass,
-                                                           String[] environments,
                                                            String[] args) {
 
         ApplicationContextBuilder builder = ApplicationContext
             .builder()
             .mainClass(mainClass)
-            .environments(environments);
+            .environments(Environment.CLI);
 
         CommandLine cmd = new CommandLine(mainClass, CommandLine.defaultFactory());
         continueOnParsingErrors(cmd);

cli/src/main/java/io/kestra/cli/commands/servers/AbstractServerCommand.java

@@ -2,27 +2,19 @@ package io.kestra.cli.commands.servers;
 
 import io.kestra.cli.AbstractCommand;
 import io.kestra.core.contexts.KestraContext;
-import lombok.extern.slf4j.Slf4j;
+import jakarta.annotation.PostConstruct;
 import picocli.CommandLine;
 
-@Slf4j
-public abstract class AbstractServerCommand extends AbstractCommand implements ServerCommandInterface {
+abstract public class AbstractServerCommand extends AbstractCommand implements ServerCommandInterface {
     @CommandLine.Option(names = {"--port"}, description = "The port to bind")
     Integer serverPort;
 
     @Override
     public Integer call()  throws Exception {
-        log.info("Machine information: {} available cpu(s), {}MB max memory, Java version {}", Runtime.getRuntime().availableProcessors(), maxMemoryInMB(), Runtime.version());
-
         this.shutdownHook(true, () -> KestraContext.getContext().shutdown());
-
         return super.call();
     }
 
-    private long maxMemoryInMB() {
-        return Runtime.getRuntime().maxMemory() / 1024 / 1024;
-    }
-
     protected static int defaultWorkerThread() {
         return Runtime.getRuntime().availableProcessors() * 8;
     }

cli/src/main/java/io/kestra/cli/commands/servers/ExecutorCommand.java

@@ -3,7 +3,7 @@ package io.kestra.cli.commands.servers;
 import com.google.common.collect.ImmutableMap;
 import io.kestra.core.models.ServerType;
 import io.kestra.core.runners.ExecutorInterface;
-import io.kestra.executor.SkipExecutionService;
+import io.kestra.core.services.SkipExecutionService;
 import io.kestra.core.services.StartExecutorService;
 import io.kestra.core.utils.Await;
 import io.micronaut.context.ApplicationContext;

cli/src/main/java/io/kestra/cli/commands/servers/IndexerCommand.java

@@ -4,10 +4,13 @@ import com.google.common.collect.ImmutableMap;
 import io.kestra.core.models.ServerType;
 import io.kestra.core.runners.Indexer;
 import io.kestra.core.utils.Await;
+import io.kestra.core.services.SkipExecutionService;
 import io.micronaut.context.ApplicationContext;
 import jakarta.inject.Inject;
 import picocli.CommandLine;
 
+import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 
 @CommandLine.Command(
@@ -17,6 +20,11 @@ import java.util.Map;
 public class IndexerCommand extends AbstractServerCommand {
     @Inject
     private ApplicationContext applicationContext;
+    @Inject
+    private SkipExecutionService skipExecutionService;
+
+    @CommandLine.Option(names = {"--skip-indexer-records"}, split=",", description = "a list of indexer record keys, separated by a coma; for troubleshooting purpose only")
+    private List<String> skipIndexerRecords = Collections.emptyList();
 
     @SuppressWarnings("unused")
     public static Map<String, Object> propertiesOverrides() {
@@ -27,6 +35,8 @@ public class IndexerCommand extends AbstractServerCommand {
 
     @Override
     public Integer call() throws Exception {
+        this.skipExecutionService.setSkipIndexerRecords(skipIndexerRecords);
+
         super.call();
 
         Indexer indexer = applicationContext.getBean(Indexer.class);

cli/src/main/java/io/kestra/cli/commands/servers/StandAloneCommand.java

@@ -7,7 +7,7 @@ import io.kestra.core.contexts.KestraContext;
 import io.kestra.core.models.ServerType;
 import io.kestra.core.repositories.LocalFlowRepositoryLoader;
 import io.kestra.cli.StandAloneRunner;
-import io.kestra.executor.SkipExecutionService;
+import io.kestra.core.services.SkipExecutionService;
 import io.kestra.core.services.StartExecutorService;
 import io.kestra.core.utils.Await;
 import io.micronaut.context.ApplicationContext;
@@ -63,6 +63,9 @@ public class StandAloneCommand extends AbstractServerCommand {
     @CommandLine.Option(names = {"--skip-tenants"}, split=",", description = "a list of tenants to skip, separated by a coma; for troubleshooting purpose only")
     private List<String> skipTenants = Collections.emptyList();
 
+    @CommandLine.Option(names = {"--skip-indexer-records"}, split=",", description = "a list of indexer record keys, separated by a coma; for troubleshooting purpose only")
+    private List<String> skipIndexerRecords = Collections.emptyList();
+
     @CommandLine.Option(names = {"--no-tutorials"}, description = "Flag to disable auto-loading of tutorial flows.")
     boolean tutorialsDisabled = false;
 
@@ -93,6 +96,7 @@ public class StandAloneCommand extends AbstractServerCommand {
         this.skipExecutionService.setSkipFlows(skipFlows);
         this.skipExecutionService.setSkipNamespaces(skipNamespaces);
         this.skipExecutionService.setSkipTenants(skipTenants);
+        this.skipExecutionService.setSkipIndexerRecords(skipIndexerRecords);
         this.startExecutorService.applyOptions(startExecutors, notStartExecutors);
 
         KestraContext.getContext().injectWorkerConfigs(workerThread, null);

cli/src/main/java/io/kestra/cli/commands/servers/WebServerCommand.java

@@ -5,12 +5,15 @@ import io.kestra.core.models.ServerType;
 import io.kestra.core.runners.Indexer;
 import io.kestra.core.utils.Await;
 import io.kestra.core.utils.ExecutorsUtils;
+import io.kestra.core.services.SkipExecutionService;
 import io.micronaut.context.ApplicationContext;
 import jakarta.inject.Inject;
 import lombok.extern.slf4j.Slf4j;
 import picocli.CommandLine;
 import picocli.CommandLine.Option;
 
+import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
 
@@ -28,11 +31,17 @@ public class WebServerCommand extends AbstractServerCommand {
     @Inject
     private ExecutorsUtils executorsUtils;
 
+    @Inject
+    private SkipExecutionService skipExecutionService;
+
     @Option(names = {"--no-tutorials"}, description = "Flag to disable auto-loading of tutorial flows.")
-    boolean tutorialsDisabled = false;
+    private boolean tutorialsDisabled = false;
 
     @Option(names = {"--no-indexer"}, description = "Flag to disable starting an embedded indexer.")
-    boolean indexerDisabled = false;
+    private boolean indexerDisabled = false;
+
+    @CommandLine.Option(names = {"--skip-indexer-records"}, split=",", description = "a list of indexer record keys, separated by a coma; for troubleshooting purpose only")
+    private List<String> skipIndexerRecords = Collections.emptyList();
 
     @Override
     public boolean isFlowAutoLoadEnabled() {
@@ -48,6 +57,8 @@ public class WebServerCommand extends AbstractServerCommand {
 
     @Override
     public Integer call() throws Exception {
+        this.skipExecutionService.setSkipIndexerRecords(skipIndexerRecords);
+
         super.call();
 
         // start the indexer

cli/src/main/java/io/kestra/cli/services/FileChangedEventListener.java

@@ -262,8 +262,6 @@ public class FileChangedEventListener {
     }
 
     private String getTenantIdFromPath(Path path) {
-        // FIXME there is probably a bug here when a tenant has '_' in its name,
-        //  a valid tenant name is defined with following regex: "^[a-z0-9][a-z0-9_-]*"
         return path.getFileName().toString().split("_")[0];
     }
 }

cli/src/main/resources/application.yml

@@ -169,6 +169,7 @@ kestra:
         - "/api/v1/executions/webhook/"
         - "/api/v1/main/executions/webhook/"
         - "/api/v1/*/executions/webhook/"
+        - "/api/v1/basicAuthValidationErrors"
 
     preview:
       initial-rows: 100

cli/src/test/java/io/kestra/cli/AppTest.java

@@ -37,7 +37,7 @@ class AppTest {
 
         final String[] args = new String[]{"server", serverType, "--help"};
 
-        try (ApplicationContext ctx = App.applicationContext(App.class, new String [] { Environment.CLI }, args)) {
+        try (ApplicationContext ctx = App.applicationContext(App.class, args)) {
             new CommandLine(App.class, new MicronautFactory(ctx)).execute(args);
 
             assertTrue(ctx.getProperty("kestra.server-type", ServerType.class).isEmpty());
@@ -52,7 +52,7 @@ class AppTest {
 
         final String[] argsWithMissingParams = new String[]{"flow", "namespace", "update"};
 
-        try (ApplicationContext ctx = App.applicationContext(App.class, new String [] { Environment.CLI }, argsWithMissingParams)) {
+        try (ApplicationContext ctx = App.applicationContext(App.class, argsWithMissingParams)) {
             new CommandLine(App.class, new MicronautFactory(ctx)).execute(argsWithMissingParams);
 
             assertThat(out.toString()).startsWith("Missing required parameters: ");

cli/src/test/java/io/kestra/cli/services/FileChangedEventListenerTest.java

@@ -4,11 +4,11 @@ import io.kestra.core.models.flows.Flow;
 import io.kestra.core.models.flows.GenericFlow;
 import io.kestra.core.repositories.FlowRepositoryInterface;
 import io.kestra.core.utils.Await;
-import io.kestra.core.utils.TestsUtils;
 import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
 import jakarta.inject.Inject;
 import org.apache.commons.io.FileUtils;
 import org.junit.jupiter.api.*;
+import org.junitpioneer.jupiter.RetryingTest;
 
 import java.io.IOException;
 import java.nio.file.Files;
@@ -18,8 +18,8 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
-import org.junitpioneer.jupiter.RetryingTest;
 
+import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static io.kestra.core.utils.Rethrow.throwRunnable;
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -57,11 +57,10 @@ class FileChangedEventListenerTest {
         }
     }
 
-    @Test
+    @RetryingTest(5) // Flaky on CI but always pass locally
     void test() throws IOException, TimeoutException {
-        var tenant = TestsUtils.randomTenant(FileChangedEventListenerTest.class.getSimpleName(), "test");
         // remove the flow if it already exists
-        flowRepository.findByIdWithSource(tenant, "io.kestra.tests.watch", "myflow").ifPresent(flow -> flowRepository.delete(flow));
+        flowRepository.findByIdWithSource(MAIN_TENANT, "io.kestra.tests.watch", "myflow").ifPresent(flow -> flowRepository.delete(flow));
 
         // create a basic flow
         String flow = """
@@ -74,14 +73,14 @@ class FileChangedEventListenerTest {
                 message: Hello World! 🚀
             """;
 
-        GenericFlow genericFlow = GenericFlow.fromYaml(tenant, flow);
+        GenericFlow genericFlow = GenericFlow.fromYaml(MAIN_TENANT, flow);
         Files.write(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"), flow.getBytes());
         Await.until(
-            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "myflow").isPresent(),
+            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "myflow").isPresent(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );
-        Flow myflow = flowRepository.findById(tenant, "io.kestra.tests.watch", "myflow").orElseThrow();
+        Flow myflow = flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "myflow").orElseThrow();
         assertThat(myflow.getTasks()).hasSize(1);
         assertThat(myflow.getTasks().getFirst().getId()).isEqualTo("hello");
         assertThat(myflow.getTasks().getFirst().getType()).isEqualTo("io.kestra.plugin.core.log.Log");
@@ -89,17 +88,16 @@ class FileChangedEventListenerTest {
         // delete the flow
         Files.delete(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"));
         Await.until(
-            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "myflow").isEmpty(),
+            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "myflow").isEmpty(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );
     }
 
-    @RetryingTest(2)
+    @RetryingTest(5) // Flaky on CI but always pass locally
     void testWithPluginDefault() throws IOException, TimeoutException {
-        var tenant = TestsUtils.randomTenant(FileChangedEventListenerTest.class.getName(), "testWithPluginDefault");
         // remove the flow if it already exists
-        flowRepository.findByIdWithSource(tenant, "io.kestra.tests.watch", "pluginDefault").ifPresent(flow -> flowRepository.delete(flow));
+        flowRepository.findByIdWithSource(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").ifPresent(flow -> flowRepository.delete(flow));
 
         // create a flow with plugin default
         String pluginDefault = """
@@ -115,14 +113,14 @@ class FileChangedEventListenerTest {
                 values:
                   message: Hello World!
             """;
-        GenericFlow genericFlow = GenericFlow.fromYaml(tenant, pluginDefault);
+        GenericFlow genericFlow = GenericFlow.fromYaml(MAIN_TENANT, pluginDefault);
         Files.write(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"), pluginDefault.getBytes());
         Await.until(
-            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "pluginDefault").isPresent(),
+            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").isPresent(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );
-        Flow pluginDefaultFlow = flowRepository.findById(tenant, "io.kestra.tests.watch", "pluginDefault").orElseThrow();
+        Flow pluginDefaultFlow = flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").orElseThrow();
         assertThat(pluginDefaultFlow.getTasks()).hasSize(1);
         assertThat(pluginDefaultFlow.getTasks().getFirst().getId()).isEqualTo("helloWithDefault");
         assertThat(pluginDefaultFlow.getTasks().getFirst().getType()).isEqualTo("io.kestra.plugin.core.log.Log");
@@ -130,7 +128,7 @@ class FileChangedEventListenerTest {
         // delete both files
         Files.delete(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"));
         Await.until(
-            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "pluginDefault").isEmpty(),
+            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").isEmpty(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );

core/build.gradle

@@ -84,7 +84,7 @@ dependencies {
 
     testImplementation "org.testcontainers:testcontainers:1.21.3"
     testImplementation "org.testcontainers:junit-jupiter:1.21.3"
-    testImplementation "org.bouncycastle:bcpkix-jdk18on"
+    testImplementation "org.bouncycastle:bcpkix-jdk18on:1.81"
 
     testImplementation "org.wiremock:wiremock-jetty12"
 }

core/src/main/java/io/kestra/core/docs/JsonSchemaGenerator.java

@@ -118,7 +118,7 @@ public class JsonSchemaGenerator {
             removeRequiredOnPropsWithDefaults(objectNode);
 
             return MAPPER.convertValue(objectNode, MAP_TYPE_REFERENCE);
-        } catch (IllegalArgumentException e) {
+        } catch (Exception e) {
             throw new IllegalArgumentException("Unable to generate jsonschema for '" + cls.getName() + "'", e);
         }
     }

core/src/main/java/io/kestra/core/models/Label.java

@@ -1,13 +1,14 @@
 package io.kestra.core.models;
 
 import io.kestra.core.utils.MapUtils;
+import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.annotation.Nullable;
 import jakarta.validation.constraints.NotEmpty;
 
 import java.util.*;
-import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
+@Schema(description = "A key/value pair that can be attached to a Flow or Execution. Labels are often used to organize and categorize objects.")
 public record Label(@NotEmpty String key, @NotEmpty String value) {
     public static final String SYSTEM_PREFIX = "system.";
 
@@ -42,7 +43,7 @@ public record Label(@NotEmpty String key, @NotEmpty String value) {
     public static Map<String, String> toMap(@Nullable List<Label> labels) {
         if (labels == null || labels.isEmpty()) return Collections.emptyMap();
         return labels.stream()
-            .filter(label -> label.value() != null && !label.value().isEmpty() && label.key() != null && !label.key().isEmpty())
+            .filter(label -> label.value() != null && label.key() != null)
             // using an accumulator in case labels with the same key exists: the second is kept
             .collect(Collectors.toMap(Label::key, Label::value, (first, second) -> second, LinkedHashMap::new));
     }
@@ -57,7 +58,6 @@ public record Label(@NotEmpty String key, @NotEmpty String value) {
     public static List<Label> deduplicate(@Nullable List<Label> labels) {
         if (labels == null || labels.isEmpty()) return Collections.emptyList();
         return toMap(labels).entrySet().stream()
-            .filter(getEntryNotEmptyPredicate())
             .map(entry -> new Label(entry.getKey(), entry.getValue()))
             .collect(Collectors.toCollection(ArrayList::new));
     }
@@ -72,7 +72,6 @@ public record Label(@NotEmpty String key, @NotEmpty String value) {
         if (map == null || map.isEmpty()) return List.of();
         return map.entrySet()
             .stream()
-            .filter(getEntryNotEmptyPredicate())
             .map(entry -> new Label(entry.getKey(), entry.getValue()))
             .toList();
     }
@@ -91,14 +90,4 @@ public record Label(@NotEmpty String key, @NotEmpty String value) {
         }
         return map;
     }
-
-    /**
-     * Provides predicate for not empty entries.
-     *
-     * @return The non-empty filter
-     */
-    public static Predicate<Map.Entry<String, String>> getEntryNotEmptyPredicate() {
-        return entry -> entry.getKey() != null && !entry.getKey().isEmpty() &&
-            entry.getValue() != null && !entry.getValue().isEmpty();
-    }
 }

core/src/main/java/io/kestra/core/models/PluginVersioning.java

@@ -1,33 +1,16 @@
 package io.kestra.core.models;
 
 import io.swagger.v3.oas.annotations.media.Schema;
-import jakarta.validation.Valid;
 import jakarta.validation.constraints.Pattern;
 
-import java.util.List;
-import java.util.Map;
-
 /**
  * Interface that can be implemented by classes supporting plugin versioning.
  *
  * @see Plugin
  */
 public interface PluginVersioning {
-    
-    String TITLE = "Plugin Version";
-    String DESCRIPTION = """
-    Defines the version of the plugin to use.
 
-    The version must follow the Semantic Versioning (SemVer) specification:
-      - A single-digit MAJOR version (e.g., `1`).
-      - A MAJOR.MINOR version (e.g., `1.1`).
-      - A MAJOR.MINOR.PATCH version, optionally with any qualifier
-        (e.g., `1.1.2`, `1.1.0-SNAPSHOT`).
-    """;
-    
-    @Schema(
-        title = TITLE,
-        description = DESCRIPTION
-    )
+    @Pattern(regexp="\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9-]+)?|([a-zA-Z0-9]+)")
+    @Schema(title = "The version of the plugin to use.")
     String getVersion();
 }

core/src/main/java/io/kestra/core/models/QueryFilter.java

@@ -254,7 +254,19 @@ public record QueryFilter(
          *
          * @return List of {@code ResourceField} with resource names, fields, and operations.
          */
-        
+        public static List<ResourceField> asResourceList() {
+            return Arrays.stream(values())
+                .map(Resource::toResourceField)
+                .toList();
+        }
+
+        private static ResourceField toResourceField(Resource resource) {
+            List<FieldOp> fieldOps = resource.supportedField().stream()
+                .map(Resource::toFieldInfo)
+                .toList();
+            return new ResourceField(resource.name().toLowerCase(), fieldOps);
+        }
+
         private static FieldOp toFieldInfo(Field field) {
             List<Operation> operations = field.supportedOp().stream()
                 .map(Resource::toOperation)
@@ -267,6 +279,9 @@ public record QueryFilter(
         }
     }
 
+    public record ResourceField(String name, List<FieldOp> fields) {
+    }
+
     public record FieldOp(String name, String value, List<Operation> operations) {
     }
 

core/src/main/java/io/kestra/core/models/collectors/ExecutionUsage.java

@@ -17,12 +17,31 @@ import java.util.List;
 @Introspected
 public class ExecutionUsage {
     private final List<DailyExecutionStatistics> dailyExecutionsCount;
+    private final List<DailyExecutionStatistics> dailyTaskRunsCount;
 
     public static ExecutionUsage of(final String tenantId,
                                     final ExecutionRepositoryInterface executionRepository,
                                     final ZonedDateTime from,
                                     final ZonedDateTime to) {
 
+        List<DailyExecutionStatistics> dailyTaskRunsCount = null;
+
+        try {
+            dailyTaskRunsCount = executionRepository.dailyStatistics(
+                null,
+                tenantId,
+                null,
+                null,
+                null,
+                from,
+                to,
+                DateUtils.GroupType.DAY,
+                null,
+                true);
+        } catch (UnsupportedOperationException ignored) {
+
+        }
+
         return ExecutionUsage.builder()
             .dailyExecutionsCount(executionRepository.dailyStatistics(
                 null,
@@ -33,13 +52,28 @@ public class ExecutionUsage {
                 from,
                 to,
                 DateUtils.GroupType.DAY,
-                null))
+                null,
+                false))
+            .dailyTaskRunsCount(dailyTaskRunsCount)
             .build();
     }
 
     public static ExecutionUsage of(final ExecutionRepositoryInterface repository,
                                     final ZonedDateTime from,
                                     final ZonedDateTime to) {
+        List<DailyExecutionStatistics> dailyTaskRunsCount = null;
+        try {
+            dailyTaskRunsCount = repository.dailyStatisticsForAllTenants(
+                null,
+                null,
+                null,
+                from,
+                to,
+                DateUtils.GroupType.DAY,
+                true
+            );
+        } catch (UnsupportedOperationException ignored) {}
+
         return ExecutionUsage.builder()
             .dailyExecutionsCount(repository.dailyStatisticsForAllTenants(
                 null,
@@ -47,8 +81,10 @@ public class ExecutionUsage {
                 null,
                 from,
                 to,
-                DateUtils.GroupType.DAY
+                DateUtils.GroupType.DAY,
+                false
             ))
+            .dailyTaskRunsCount(dailyTaskRunsCount)
             .build();
     }
 }

core/src/main/java/io/kestra/core/models/executions/Execution.java

@@ -272,7 +272,7 @@ public class Execution implements DeletedInterface, TenantInterface {
     }
 
     public Execution withTaskRun(TaskRun taskRun) throws InternalException {
-        ArrayList<TaskRun> newTaskRunList = new ArrayList<>(this.taskRunList);
+        ArrayList<TaskRun> newTaskRunList = this.taskRunList == null ? new ArrayList<>() : new ArrayList<>(this.taskRunList);
 
         boolean b = Collections.replaceAll(
             newTaskRunList,
@@ -865,18 +865,20 @@ public class Execution implements DeletedInterface, TenantInterface {
      * @param e the exception raise
      * @return new taskRun with updated attempt with logs
      */
-    private FailedTaskRunWithLog lastAttemptsTaskRunForFailedExecution(TaskRun taskRun, TaskRunAttempt lastAttempt, Exception e) {
-        TaskRun failed = taskRun
-            .withAttempts(
-                Stream
-                    .concat(
-                        taskRun.getAttempts().stream().limit(taskRun.getAttempts().size() - 1),
-                        Stream.of(lastAttempt.getState().isFailed() ? lastAttempt : lastAttempt.withState(State.Type.FAILED))
-                    )
-                    .toList()
-            );
+    private FailedTaskRunWithLog lastAttemptsTaskRunForFailedExecution(TaskRun taskRun,
+        TaskRunAttempt lastAttempt, Exception e) {
         return new FailedTaskRunWithLog(
-            failed.getState().isFailed() ? failed : failed.withState(State.Type.FAILED),
+            taskRun
+                .withAttempts(
+                    Stream
+                        .concat(
+                            taskRun.getAttempts().stream().limit(taskRun.getAttempts().size() - 1),
+                            Stream.of(lastAttempt
+                                .withState(State.Type.FAILED))
+                        )
+                        .toList()
+                )
+                .withState(State.Type.FAILED),
             RunContextLogger.logEntries(loggingEventFromException(e), LogEntry.of(taskRun, kind))
         );
     }

core/src/main/java/io/kestra/core/models/flows/AbstractFlow.java

@@ -3,7 +3,6 @@ package io.kestra.core.models.flows;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import io.kestra.core.models.Label;
-import io.kestra.core.models.annotations.PluginProperty;
 import io.kestra.core.models.tasks.WorkerGroup;
 import io.kestra.core.serializers.ListOrMapOfLabelDeserializer;
 import io.kestra.core.serializers.ListOrMapOfLabelSerializer;
@@ -61,7 +60,13 @@ public abstract class AbstractFlow implements FlowInterface {
 
     @JsonSerialize(using = ListOrMapOfLabelSerializer.class)
     @JsonDeserialize(using = ListOrMapOfLabelDeserializer.class)
-    @Schema(implementation = Object.class, oneOf = {List.class, Map.class})
+    @Schema(
+            description = "Labels as a list of Label (key/value pairs) or as a map of string to string.",
+            oneOf = {
+                    Label[].class,
+                    Map.class
+            }
+    )
     @Valid
     List<Label> labels;
 
@@ -70,4 +75,5 @@ public abstract class AbstractFlow implements FlowInterface {
 
     @Valid
     private WorkerGroup workerGroup;
+
 }

core/src/main/java/io/kestra/core/plugins/DefaultPluginRegistry.java

@@ -56,7 +56,7 @@ public class DefaultPluginRegistry implements PluginRegistry {
      *
      * @return the {@link DefaultPluginRegistry}.
      */
-    public synchronized static DefaultPluginRegistry getOrCreate() {
+    public static DefaultPluginRegistry getOrCreate() {
         DefaultPluginRegistry instance = LazyHolder.INSTANCE;
         if (!instance.isInitialized()) {
             instance.init();
@@ -74,7 +74,7 @@ public class DefaultPluginRegistry implements PluginRegistry {
     /**
      * Initializes the registry by loading all core plugins.
      */
-    protected synchronized void init() {
+    protected void init() {
         if (initialized.compareAndSet(false, true)) {
             register(scanner.scan());
         }
@@ -200,7 +200,7 @@ public class DefaultPluginRegistry implements PluginRegistry {
         if (existing != null && existing.crc32() == plugin.crc32()) {
             return; // same plugin already registered
         }
-
+        
         lock.lock();
         try {
             if (existing != null) {
@@ -212,7 +212,7 @@ public class DefaultPluginRegistry implements PluginRegistry {
             lock.unlock();
         }
     }
-
+    
     protected void registerAll(Map<PluginIdentifier, PluginClassAndMetadata<? extends Plugin>> plugins) {
         pluginClassByIdentifier.putAll(plugins);
     }

core/src/main/java/io/kestra/core/plugins/serdes/PluginDeserializer.java

@@ -144,7 +144,7 @@ public final class PluginDeserializer<T extends Plugin> extends JsonDeserializer
 
     static String extractPluginRawIdentifier(final JsonNode node, final boolean isVersioningSupported) {
         String type = Optional.ofNullable(node.get(TYPE)).map(JsonNode::textValue).orElse(null);
-        String version = Optional.ofNullable(node.get(VERSION)).map(JsonNode::asText).orElse(null);
+        String version = Optional.ofNullable(node.get(VERSION)).map(JsonNode::textValue).orElse(null);
 
         if (type == null || type.isEmpty()) {
             return null;

core/src/main/java/io/kestra/core/queues/QueueFactoryInterface.java

@@ -27,6 +27,7 @@ public interface QueueFactoryInterface {
     String CLUSTER_EVENT_NAMED = "clusterEventQueue";
     String SUBFLOWEXECUTIONEND_NAMED = "subflowExecutionEndQueue";
     String EXECUTION_RUNNING_NAMED = "executionRunningQueue";
+    String MULTIPLE_CONDITION_EVENT_NAMED = "multipleConditionEventQueue";
 
     QueueInterface<Execution> execution();
 
@@ -59,4 +60,6 @@ public interface QueueFactoryInterface {
     QueueInterface<SubflowExecutionEnd> subflowExecutionEnd();
 
     QueueInterface<ExecutionRunning> executionRunning();
+
+    QueueInterface<MultipleConditionEvent> multipleConditionEvent();
 }

core/src/main/java/io/kestra/core/repositories/ExecutionRepositoryInterface.java

@@ -25,6 +25,8 @@ import java.util.Optional;
 import java.util.function.Function;
 
 public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Execution>, QueryBuilderInterface<Executions.Fields> {
+    Boolean isTaskRunEnabled();
+
     default Optional<Execution> findById(String tenantId, String id) {
         return findById(tenantId, id, false);
     }
@@ -94,17 +96,26 @@ public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Ex
 
     Flux<Execution> findAllAsync(@Nullable String tenantId);
 
+    ArrayListTotal<TaskRun> findTaskRun(
+        Pageable pageable,
+        @Nullable String tenantId,
+        List<QueryFilter> filters
+    );
+
     Execution delete(Execution execution);
 
     Integer purge(Execution execution);
 
+    Integer purge(List<Execution> executions);
+
     List<DailyExecutionStatistics> dailyStatisticsForAllTenants(
         @Nullable String query,
         @Nullable String namespace,
         @Nullable String flowId,
         @Nullable ZonedDateTime startDate,
         @Nullable ZonedDateTime endDate,
-        @Nullable DateUtils.GroupType groupBy
+        @Nullable DateUtils.GroupType groupBy,
+        boolean isTaskRun
     );
 
     List<DailyExecutionStatistics> dailyStatistics(
@@ -116,7 +127,8 @@ public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Ex
         @Nullable ZonedDateTime startDate,
         @Nullable ZonedDateTime endDate,
         @Nullable DateUtils.GroupType groupBy,
-        List<State.Type> state
+        List<State.Type> state,
+        boolean isTaskRun
     );
 
     @Getter

core/src/main/java/io/kestra/core/repositories/LocalFlowRepositoryLoader.java

@@ -83,9 +83,7 @@ public class LocalFlowRepositoryLoader {
     }
 
     public void load(String tenantId, File basePath) throws IOException {
-        Map<String, FlowInterface> flowByUidInRepository = flowRepository.findAllForAllTenants()
-            .stream()
-            .filter(flow -> tenantId.equals(flow.getTenantId()))
+        Map<String, FlowInterface> flowByUidInRepository = flowRepository.findAllForAllTenants().stream()
             .collect(Collectors.toMap(FlowId::uidWithoutRevision, Function.identity()));
 
         try (Stream<Path> pathStream = Files.walk(basePath.toPath())) {

core/src/main/java/io/kestra/core/repositories/LogRepositoryInterface.java

@@ -90,6 +90,8 @@ public interface LogRepositoryInterface extends SaveRepositoryInterface<LogEntry
 
     Integer purge(Execution execution);
 
+    Integer purge(List<Execution> executions);
+
     void deleteByQuery(String tenantId, String executionId, String taskId, String taskRunId, Level minLevel, Integer attempt);
 
     void deleteByQuery(String tenantId, String namespace, String flowId, String triggerId);

core/src/main/java/io/kestra/core/repositories/MetricRepositoryInterface.java

@@ -29,6 +29,8 @@ public interface MetricRepositoryInterface extends SaveRepositoryInterface<Metri
 
     Integer purge(Execution execution);
 
+    Integer purge(List<Execution> executions);
+
     Flux<MetricEntry> findAllAsync(@Nullable String tenantId);
 
     default Function<String, String> sortMapping() throws IllegalArgumentException {

core/src/main/java/io/kestra/core/runners/ExecutableUtils.java

@@ -5,7 +5,10 @@ import io.kestra.core.exceptions.IllegalVariableEvaluationException;
 import io.kestra.core.exceptions.InternalException;
 import io.kestra.core.models.Label;
 import io.kestra.core.models.executions.*;
-import io.kestra.core.models.flows.*;
+import io.kestra.core.models.flows.Flow;
+import io.kestra.core.models.flows.FlowInterface;
+import io.kestra.core.models.flows.FlowWithException;
+import io.kestra.core.models.flows.State;
 import io.kestra.core.models.property.Property;
 import io.kestra.core.models.tasks.ExecutableTask;
 import io.kestra.core.models.tasks.Task;
@@ -26,7 +29,6 @@ import org.apache.commons.lang3.stream.Streams;
 import java.time.Instant;
 import java.time.ZonedDateTime;
 import java.util.*;
-import java.util.stream.Collectors;
 
 import static io.kestra.core.trace.Tracer.throwCallable;
 import static io.kestra.core.utils.Rethrow.throwConsumer;
@@ -151,24 +153,17 @@ public final class ExecutableUtils {
                     currentFlow.getNamespace(),
                     currentFlow.getId()
                 )
-                .orElseThrow(() -> {
-                    String msg = "Unable to find flow '" + subflowNamespace + "'.'" + subflowId + "' with revision '" + subflowRevision.orElse(0) + "'";
-                    runContext.logger().error(msg);
-                    return new IllegalStateException(msg);
-                });
+                .orElseThrow(() -> new IllegalStateException("Unable to find flow '" + subflowNamespace + "'.'" + subflowId + "' with revision '" + subflowRevision.orElse(0) + "'"));
 
             if (flow.isDisabled()) {
-                String msg = "Cannot execute a flow which is disabled";
-                runContext.logger().error(msg);
-                throw new IllegalStateException(msg);
+                throw new IllegalStateException("Cannot execute a flow which is disabled");
             }
 
             if (flow instanceof FlowWithException fwe) {
-                String msg = "Cannot execute an invalid flow: " + fwe.getException();
-                runContext.logger().error(msg);
-                throw new IllegalStateException(msg);
+                throw new IllegalStateException("Cannot execute an invalid flow: " + fwe.getException());
             }
-                List<Label> newLabels = inheritLabels ? new ArrayList<>(filterLabels(currentExecution.getLabels(), flow)) : new ArrayList<>(systemLabels(currentExecution));
+
+            List<Label> newLabels = inheritLabels ? new ArrayList<>(filterLabels(currentExecution.getLabels(), flow)) : new ArrayList<>(systemLabels(currentExecution));
             if (labels != null) {
                 labels.forEach(throwConsumer(label -> newLabels.add(new Label(runContext.render(label.key()), runContext.render(label.value())))));
             }
@@ -206,20 +201,7 @@ public final class ExecutableUtils {
                     .build()
                 )
                 .withScheduleDate(scheduleOnDate);
-                if(execution.getInputs().size()<inputs.size()) {
-                    Map<String,Object>resolvedInputs=execution.getInputs();
-                    for (var inputKey : inputs.keySet()) {
-                        if (!resolvedInputs.containsKey(inputKey)) {
-                            runContext.logger().warn(
-                                "Input {} was provided by parent execution {} for subflow {}.{} but isn't declared at the subflow inputs",
-                                inputKey,
-                                currentExecution.getId(),
-                                currentTask.subflowId().namespace(),
-                                currentTask.subflowId().flowId()
-                            );
-                        }
-                    }
-                }
+
             // inject the traceparent into the new execution
             propagator.ifPresent(pg -> pg.inject(Context.current(), execution, ExecutionTextMapSetter.INSTANCE));
 

core/src/main/java/io/kestra/core/runners/ExecutionRunning.java

@@ -32,5 +32,7 @@ public class ExecutionRunning implements HasUID {
         return IdUtils.fromPartsAndSeparator('|', this.tenantId, this.namespace, this.flowId, this.execution.getId());
     }
 
-    public enum ConcurrencyState { CREATED, RUNNING, QUEUED, CANCELLED, FAILED }
+    // Note: the KILLED state is only used in the Kafka implementation to difference between purging terminated running execution (null)
+    // and purging killed execution which need special treatment
+    public enum ConcurrencyState { CREATED, RUNNING, QUEUED, CANCELLED, FAILED, KILLED }
 }

core/src/main/java/io/kestra/core/runners/FlowInputOutput.java

@@ -1,7 +1,6 @@
 package io.kestra.core.runners;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.common.annotations.VisibleForTesting;
 import io.kestra.core.encryption.EncryptionService;
 import io.kestra.core.exceptions.IllegalVariableEvaluationException;
 import io.kestra.core.exceptions.KestraRuntimeException;
@@ -49,7 +48,15 @@ import java.time.Duration;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalTime;
-import java.util.*;
+import java.util.AbstractMap;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.regex.Matcher;
@@ -65,31 +72,28 @@ import static io.kestra.core.utils.Rethrow.throwFunction;
 public class FlowInputOutput {
     private static final Pattern URI_PATTERN = Pattern.compile("^[a-z]+:\\/\\/(?:www\\.)?[-a-zA-Z0-9@:%._\\+~#=]{1,256}\\.[a-zA-Z0-9()]{1,6}\\b(?:[-a-zA-Z0-9()@:%_\\+.~#?&\\/=]*)$");
     private static final ObjectMapper YAML_MAPPER = JacksonMapper.ofYaml();
-
+    
     private final StorageInterface storageInterface;
     private final Optional<String> secretKey;
     private final RunContextFactory runContextFactory;
-    private final VariableRenderer variableRenderer;
-
+    
     @Inject
     public FlowInputOutput(
         StorageInterface storageInterface,
         RunContextFactory runContextFactory,
-        VariableRenderer variableRenderer,
         @Nullable @Value("${kestra.encryption.secret-key}") String secretKey
     ) {
         this.storageInterface = storageInterface;
         this.runContextFactory = runContextFactory;
         this.secretKey = Optional.ofNullable(secretKey);
-        this.variableRenderer = variableRenderer;
     }
-
+    
     /**
      * Validate all the inputs of a given execution of a flow.
      *
-     * @param inputs                  The Flow's inputs.
-     * @param execution               The Execution.
-     * @param data                    The Execution's inputs data.
+     * @param inputs    The Flow's inputs.
+     * @param execution The Execution.
+     * @param data      The Execution's inputs data.
      * @return The list of {@link InputAndValue}.
      */
     public Mono<List<InputAndValue>> validateExecutionInputs(final List<Input<?>> inputs,
@@ -97,10 +101,11 @@ public class FlowInputOutput {
                                                              final Execution execution,
                                                              final Publisher<CompletedPart> data) {
         if (ListUtils.isEmpty(inputs)) return Mono.just(Collections.emptyList());
-
-        return readData(inputs, execution, data, false).map(inputData -> resolveInputs(inputs, flow, execution, inputData));
+        
+        return readData(inputs, execution, data, false)
+            .map(inputData -> resolveInputs(inputs, flow, execution, inputData, false));
     }
-
+    
     /**
      * Reads all the inputs of a given execution of a flow.
      *
@@ -114,7 +119,7 @@ public class FlowInputOutput {
                                                          final Publisher<CompletedPart> data) {
         return this.readExecutionInputs(flow.getInputs(), flow, execution, data);
     }
-
+    
     /**
      * Reads all the inputs of a given execution of a flow.
      *
@@ -129,7 +134,7 @@ public class FlowInputOutput {
                                                          final Publisher<CompletedPart> data) {
         return readData(inputs, execution, data, true).map(inputData -> this.readExecutionInputs(inputs, flow, execution, inputData));
     }
-
+    
     private Mono<Map<String, Object>> readData(List<Input<?>> inputs, Execution execution, Publisher<CompletedPart> data, boolean uploadFiles) {
         return Flux.from(data)
             .publishOn(Schedulers.boundedElastic())
@@ -212,7 +217,7 @@ public class FlowInputOutput {
         final Execution execution,
         final Map<String, ?> data
     ) {
-        Map<String, Object> resolved = this.resolveInputs(inputs, flow, execution, data)
+        Map<String, Object> resolved = this.resolveInputs(inputs, flow, execution, data, true)
             .stream()
             .filter(InputAndValue::enabled)
             .map(it -> {
@@ -223,22 +228,9 @@ public class FlowInputOutput {
                 return new AbstractMap.SimpleEntry<>(it.input().getId(), it.value());
             })
             .collect(HashMap::new, (m,v)-> m.put(v.getKey(), v.getValue()), HashMap::putAll);
-        if (resolved.size() < data.size()) {
-            RunContext runContext = runContextFactory.of(flow, execution);
-            for (var inputKey : data.keySet()) {
-                if (!resolved.containsKey(inputKey)) {
-                    runContext.logger().warn(
-                        "Input {} was provided for workflow {}.{} but isn't declared in the workflow inputs",
-                        inputKey,
-                        flow.getNamespace(),
-                        flow.getId()
-                    );
-                }
-            }
-        }
         return MapUtils.flattenToNestedMap(resolved);
     }
-
+    
     /**
      * Utility method for retrieving types inputs.
      *
@@ -247,12 +239,21 @@ public class FlowInputOutput {
      * @param data      The Execution's inputs data.
      * @return The Map of typed inputs.
      */
-    @VisibleForTesting
     public List<InputAndValue> resolveInputs(
         final List<Input<?>> inputs,
         final FlowInterface flow,
         final Execution execution,
         final Map<String, ?> data
+    ) {
+        return resolveInputs(inputs, flow, execution, data, true);
+    }
+    
+    public List<InputAndValue> resolveInputs(
+        final List<Input<?>> inputs,
+        final FlowInterface flow,
+        final Execution execution,
+        final Map<String, ?> data,
+        final boolean decryptSecrets
     ) {
         if (inputs == null) {
             return Collections.emptyList();
@@ -262,7 +263,7 @@ public class FlowInputOutput {
             .map(input -> ResolvableInput.of(input,data.get(input.getId())))
             .collect(Collectors.toMap(it -> it.get().input().getId(), Function.identity(), (o1, o2) -> o1, LinkedHashMap::new)));
 
-        resolvableInputMap.values().forEach(input -> resolveInputValue(input, flow, execution, resolvableInputMap));
+        resolvableInputMap.values().forEach(input -> resolveInputValue(input, flow, execution, resolvableInputMap, decryptSecrets));
 
         return resolvableInputMap.values().stream().map(ResolvableInput::get).toList();
     }
@@ -272,7 +273,8 @@ public class FlowInputOutput {
         final @NotNull ResolvableInput resolvable,
         final FlowInterface flow,
         final @NotNull Execution execution,
-        final @NotNull Map<String, ResolvableInput> inputs) {
+        final @NotNull Map<String, ResolvableInput> inputs,
+        final boolean decryptSecrets) {
 
         // return immediately if the input is already resolved
         if (resolvable.isResolved()) return resolvable.get();
@@ -281,8 +283,8 @@ public class FlowInputOutput {
 
         try {
             //  resolve all input dependencies and check whether input is enabled
-            final Map<String, InputAndValue> dependencies = resolveAllDependentInputs(input, flow, execution, inputs);
-            final RunContext runContext = buildRunContextForExecutionAndInputs(flow, execution, dependencies);
+            final Map<String, InputAndValue> dependencies = resolveAllDependentInputs(input, flow, execution, inputs, decryptSecrets);
+            final RunContext runContext = buildRunContextForExecutionAndInputs(flow, execution, dependencies, decryptSecrets);
 
             boolean isInputEnabled = dependencies.isEmpty() || dependencies.values().stream().allMatch(InputAndValue::enabled);
 
@@ -317,16 +319,15 @@ public class FlowInputOutput {
                 }
             });
             resolvable.setInput(input);
-
-
+            
             Object value = resolvable.get().value();
-
+            
             // resolve default if needed
             if (value == null && input.getDefaults() != null) {
                 value = resolveDefaultValue(input, runContext);
                 resolvable.isDefault(true);
             }
-
+            
             // validate and parse input value
             if (value == null) {
                 if (input.getRequired()) {
@@ -355,7 +356,7 @@ public class FlowInputOutput {
 
         return resolvable.get();
     }
-
+    
     public static Object resolveDefaultValue(Input<?> input, PropertyContext renderer) throws IllegalVariableEvaluationException {
         return switch (input.getType()) {
             case STRING, ENUM, SELECT, SECRET, EMAIL -> resolveDefaultPropertyAs(input, renderer, String.class);
@@ -372,7 +373,7 @@ public class FlowInputOutput {
             case MULTISELECT -> resolveDefaultPropertyAsList(input, renderer, String.class);
         };
     }
-
+    
     @SuppressWarnings("unchecked")
     private static <T> Object resolveDefaultPropertyAs(Input<?> input, PropertyContext renderer, Class<T> clazz) throws IllegalVariableEvaluationException {
         return Property.as((Property<T>) input.getDefaults(), renderer, clazz);
@@ -382,7 +383,7 @@ public class FlowInputOutput {
         return Property.asList((Property<List<T>>) input.getDefaults(), renderer, clazz);
     }
 
-    private RunContext buildRunContextForExecutionAndInputs(final FlowInterface flow, final Execution execution, Map<String, InputAndValue> dependencies) {
+    private RunContext buildRunContextForExecutionAndInputs(final FlowInterface flow, final Execution execution, Map<String, InputAndValue> dependencies, final boolean decryptSecrets) {
         Map<String, Object> flattenInputs = MapUtils.flattenToNestedMap(dependencies.entrySet()
             .stream()
             .collect(HashMap::new, (m, v) -> m.put(v.getKey(), v.getValue().value()), HashMap::putAll)
@@ -396,10 +397,10 @@ public class FlowInputOutput {
                 flattenInputs.put(input.getId(), null);
             }
         }
-        return runContextFactory.of(flow, execution, vars -> vars.withInputs(flattenInputs));
+        return runContextFactory.of(flow, execution, vars -> vars.withInputs(flattenInputs), decryptSecrets);
     }
 
-    private Map<String, InputAndValue> resolveAllDependentInputs(final Input<?> input, final FlowInterface flow, final Execution execution, final Map<String, ResolvableInput> inputs) {
+    private Map<String, InputAndValue> resolveAllDependentInputs(final Input<?> input, final FlowInterface flow, final Execution execution, final Map<String, ResolvableInput> inputs, final boolean decryptSecrets) {
         return Optional.ofNullable(input.getDependsOn())
             .map(DependsOn::inputs)
             .stream()
@@ -407,7 +408,7 @@ public class FlowInputOutput {
             .filter(id -> !id.equals(input.getId()))
             .map(inputs::get)
             .filter(Objects::nonNull) // input may declare unknown or non-necessary dependencies. Let's ignore.
-            .map(it -> resolveInputValue(it, flow, execution, inputs))
+            .map(it -> resolveInputValue(it, flow, execution, inputs, decryptSecrets))
             .collect(Collectors.toMap(it -> it.input().getId(), Function.identity()));
     }
 
@@ -458,7 +459,7 @@ public class FlowInputOutput {
         if (data.getType() == null) {
             return Optional.of(new AbstractMap.SimpleEntry<>(data.getId(), current));
         }
-
+        
         final Type elementType = data instanceof ItemTypeInterface itemTypeInterface ? itemTypeInterface.getItemType() : null;
 
         return Optional.of(new AbstractMap.SimpleEntry<>(
@@ -535,17 +536,17 @@ public class FlowInputOutput {
             throw new Exception("Expected `" + type + "` but received `" + current + "` with errors:\n```\n" + e.getMessage() + "\n```");
         }
     }
-
+    
     public static Map<String, Object> renderFlowOutputs(List<Output> outputs, RunContext runContext) throws IllegalVariableEvaluationException {
         if (outputs == null) return Map.of();
-
+        
         // render required outputs
         Map<String, Object> outputsById = outputs
             .stream()
             .filter(output -> output.getRequired() == null || output.getRequired())
             .collect(HashMap::new, (map, entry) -> map.put(entry.getId(), entry.getValue()), Map::putAll);
         outputsById = runContext.render(outputsById);
-
+        
         // render optional outputs one by one to catch, log, and skip any error.
         for (io.kestra.core.models.flows.Output output : outputs) {
             if (Boolean.FALSE.equals(output.getRequired())) {
@@ -588,9 +589,9 @@ public class FlowInputOutput {
         }
 
         public void isDefault(boolean isDefault) {
-            this.input = new InputAndValue(this.input.input(), this.input.value(), this.input.enabled(), isDefault, this.input.exception());
+            this.input = new InputAndValue(this.input.input(), this.input.value(), this.input.enabled(), isDefault, this.input.exception());  
         }
-
+        
         public void setInput(final Input<?> input) {
             this.input = new InputAndValue(input, this.input.value(), this.input.enabled(), this.input.isDefault(), this.input.exception());
         }

core/src/main/java/io/kestra/core/runners/MultipleConditionEvent.java

@@ -0,0 +1,13 @@
+package io.kestra.core.runners;
+
+import io.kestra.core.models.HasUID;
+import io.kestra.core.models.executions.Execution;
+import io.kestra.core.models.flows.Flow;
+import io.kestra.core.utils.IdUtils;
+
+public record MultipleConditionEvent(Flow flow, Execution execution) implements HasUID {
+    @Override
+    public String uid() {
+        return IdUtils.fromParts(flow.uidWithoutRevision(), execution.getId());
+    }
+}

core/src/main/java/io/kestra/core/runners/RunContextFactory.java

@@ -41,6 +41,9 @@ public class RunContextFactory {
 
     @Inject
     protected VariableRenderer variableRenderer;
+    
+    @Inject
+    protected SecureVariableRendererFactory secureVariableRendererFactory;
 
     @Inject
     protected StorageInterface storageInterface;
@@ -82,22 +85,33 @@ public class RunContextFactory {
     public RunContext of(FlowInterface flow, Execution execution) {
         return of(flow, execution, Function.identity());
     }
+    
+    public RunContext of(FlowInterface flow, Execution execution, boolean decryptVariable) {
+        return of(flow, execution, Function.identity(), decryptVariable);
+    }
 
     public RunContext of(FlowInterface flow, Execution execution, Function<RunVariables.Builder, RunVariables.Builder> runVariableModifier) {
+        return of(flow, execution, runVariableModifier, true);
+    }
+    
+    public RunContext of(FlowInterface flow, Execution execution, Function<RunVariables.Builder, RunVariables.Builder> runVariableModifier, boolean decryptVariables) {
         RunContextLogger runContextLogger = runContextLoggerFactory.create(execution);
-
+        
+        VariableRenderer variableRenderer = decryptVariables ? this.variableRenderer : secureVariableRendererFactory.createOrGet();
+        
         return newBuilder()
             // Logger
             .withLogger(runContextLogger)
             // Execution
             .withPluginConfiguration(Map.of())
             .withStorage(new InternalStorage(runContextLogger.logger(), StorageContext.forExecution(execution), storageInterface, flowService))
+            .withVariableRenderer(variableRenderer)
             .withVariables(runVariableModifier.apply(
-                newRunVariablesBuilder()
-                    .withFlow(flow)
-                    .withExecution(execution)
-                    .withDecryptVariables(true)
-                    .withSecretInputs(secretInputsFromFlow(flow))
+                    newRunVariablesBuilder()
+                        .withFlow(flow)
+                        .withExecution(execution)
+                        .withDecryptVariables(decryptVariables)
+                        .withSecretInputs(secretInputsFromFlow(flow))
                 )
                 .build(runContextLogger, PropertyContext.create(variableRenderer)))
             .withSecretInputs(secretInputsFromFlow(flow))
@@ -109,7 +123,7 @@ public class RunContextFactory {
     }
 
     public RunContext of(FlowInterface flow, Task task, Execution execution, TaskRun taskRun, boolean decryptVariables) {
-        return this.of(flow, task, execution, taskRun, decryptVariables, variableRenderer);
+        return this.of(flow, task, execution, taskRun, decryptVariables, this.variableRenderer);
     }
 
     public RunContext of(FlowInterface flow, Task task, Execution execution, TaskRun taskRun, boolean decryptVariables, VariableRenderer variableRenderer) {
@@ -147,7 +161,7 @@ public class RunContextFactory {
                 .withFlow(flow)
                 .withTrigger(trigger)
                 .withSecretInputs(secretInputsFromFlow(flow))
-                .build(runContextLogger, PropertyContext.create(variableRenderer))
+                .build(runContextLogger, PropertyContext.create(this.variableRenderer))
             )
             .withSecretInputs(secretInputsFromFlow(flow))
             .withTrigger(trigger)
@@ -226,7 +240,7 @@ public class RunContextFactory {
             // inject mandatory services and config
             .withApplicationContext(applicationContext) // TODO - ideally application should not be injected here
             .withMeterRegistry(metricRegistry)
-            .withVariableRenderer(variableRenderer)
+            .withVariableRenderer(this.variableRenderer)
             .withStorageInterface(storageInterface)
             .withSecretKey(secretKey)
             .withWorkingDir(workingDirFactory.createWorkingDirectory())

core/src/main/java/io/kestra/core/runners/SecureVariableRendererFactory.java

@@ -0,0 +1,39 @@
+package io.kestra.core.runners;
+
+import io.kestra.core.runners.pebble.PebbleEngineFactory;
+import io.kestra.core.runners.pebble.functions.SecretFunction;
+import io.micronaut.context.ApplicationContext;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
+import java.util.List;
+
+@Singleton
+public class SecureVariableRendererFactory {
+    
+    private final PebbleEngineFactory pebbleEngineFactory;
+    private final ApplicationContext applicationContext;
+    
+    private VariableRenderer secureVariableRenderer;
+    
+    @Inject
+    public SecureVariableRendererFactory(ApplicationContext applicationContext, PebbleEngineFactory pebbleEngineFactory) {
+        this.pebbleEngineFactory = pebbleEngineFactory;
+        this.applicationContext = applicationContext;
+    }
+    
+    /**
+     * Creates or returns the existing secured {@link VariableRenderer} instance.
+     *
+     * @return the secured {@link VariableRenderer} instance
+     */
+    public synchronized VariableRenderer createOrGet() {
+        if (this.secureVariableRenderer == null) {
+            // Explicitly create a new instance through the application context to ensure
+            // eventual custom VariableRenderer implementation is used
+            secureVariableRenderer = applicationContext.createBean(VariableRenderer.class);
+            secureVariableRenderer.setPebbleEngine(pebbleEngineFactory.createWithMaskedFunctions(secureVariableRenderer, List.of(SecretFunction.NAME)));
+        }
+        return secureVariableRenderer;
+    }
+}
+

core/src/main/java/io/kestra/core/runners/VariableRenderer.java

@@ -2,121 +2,44 @@ package io.kestra.core.runners;
 
 import io.kestra.core.exceptions.IllegalVariableEvaluationException;
 import io.kestra.core.runners.pebble.*;
-import io.kestra.core.runners.pebble.functions.RenderingFunctionInterface;
 import io.micronaut.context.ApplicationContext;
 import io.micronaut.context.annotation.ConfigurationProperties;
 import io.micronaut.core.annotation.Nullable;
 import io.pebbletemplates.pebble.PebbleEngine;
 import io.pebbletemplates.pebble.error.AttributeNotFoundException;
 import io.pebbletemplates.pebble.error.PebbleException;
-import io.pebbletemplates.pebble.extension.Extension;
-import io.pebbletemplates.pebble.extension.Function;
 import io.pebbletemplates.pebble.template.PebbleTemplate;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
 import lombok.Getter;
 
 import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Proxy;
 import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-import java.util.stream.Collectors;
 
 @Singleton
 public class VariableRenderer {
     private static final Pattern RAW_PATTERN = Pattern.compile("(\\{%-*\\s*raw\\s*-*%}(.*?)\\{%-*\\s*endraw\\s*-*%})");
     public static final int MAX_RENDERING_AMOUNT = 100;
 
-    private final PebbleEngine pebbleEngine;
+    private PebbleEngine pebbleEngine;
     private final VariableConfiguration variableConfiguration;
 
     @Inject
     public VariableRenderer(ApplicationContext applicationContext, @Nullable VariableConfiguration variableConfiguration) {
-        this(applicationContext, variableConfiguration, Collections.emptyList());
+        this(applicationContext.getBean(PebbleEngineFactory.class), variableConfiguration);
     }
-
-    public VariableRenderer(ApplicationContext applicationContext, @Nullable VariableConfiguration variableConfiguration, List<String> functionsToMask) {
+    
+    public VariableRenderer(PebbleEngineFactory pebbleEngineFactory, @Nullable VariableConfiguration variableConfiguration) {
         this.variableConfiguration = variableConfiguration != null ? variableConfiguration : new VariableConfiguration();
-
-        PebbleEngine.Builder pebbleBuilder = new PebbleEngine.Builder()
-            .registerExtensionCustomizer(ExtensionCustomizer::new)
-            .strictVariables(true)
-            .cacheActive(this.variableConfiguration.getCacheEnabled())
-            .newLineTrimming(false)
-            .autoEscaping(false);
-
-        List<Extension> extensions = applicationContext.getBeansOfType(Extension.class).stream()
-            .map(e -> functionsToMask.stream().anyMatch(excludedFunction -> e.getFunctions().containsKey(excludedFunction))
-                ? extensionWithMaskedFunctions(e, functionsToMask)
-                : e)
-            .toList();
-
-        extensions.forEach(pebbleBuilder::extension);
-
-        if (this.variableConfiguration.getCacheEnabled()) {
-            pebbleBuilder.templateCache(new PebbleLruCache(this.variableConfiguration.getCacheSize()));
-        }
-
-        this.pebbleEngine = pebbleBuilder.build();
+        this.pebbleEngine = pebbleEngineFactory.create();
     }
-
-    private Extension extensionWithMaskedFunctions(Extension initialExtension, List<String> maskedFunctions) {
-        return (Extension) Proxy.newProxyInstance(
-            initialExtension.getClass().getClassLoader(),
-            new Class[]{Extension.class},
-            (proxy, method, methodArgs) -> {
-                if (method.getName().equals("getFunctions")) {
-                    return initialExtension.getFunctions().entrySet().stream()
-                        .map(entry -> {
-                            if (maskedFunctions.contains(entry.getKey())) {
-                                return Map.entry(entry.getKey(), this.maskedFunctionProxy(entry.getValue()));
-                            } else if (RenderingFunctionInterface.class.isAssignableFrom(entry.getValue().getClass())) {
-                                return Map.entry(entry.getKey(), this.variableRendererProxy(entry.getValue()));
-                            }
-
-                            return entry;
-                        }).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-                }
-
-                return method.invoke(initialExtension, methodArgs);
-            }
-        );
+    
+    public void setPebbleEngine(final PebbleEngine pebbleEngine) {
+        this.pebbleEngine = pebbleEngine;
     }
-
-    private Function variableRendererProxy(Function initialFunction) {
-        return (Function) Proxy.newProxyInstance(
-            initialFunction.getClass().getClassLoader(),
-            new Class[]{Function.class, RenderingFunctionInterface.class},
-            (functionProxy, functionMethod, functionArgs) -> {
-                if (functionMethod.getName().equals("variableRenderer")) {
-                    return this;
-                }
-                return functionMethod.invoke(initialFunction, functionArgs);
-            }
-        );
-    }
-
-    private Function maskedFunctionProxy(Function initialFunction) {
-        return (Function) Proxy.newProxyInstance(
-            initialFunction.getClass().getClassLoader(),
-            new Class[]{Function.class},
-            (functionProxy, functionMethod, functionArgs) -> {
-                Object result;
-                try {
-                    result = functionMethod.invoke(initialFunction, functionArgs);
-                } catch (InvocationTargetException e) {
-                    throw e.getCause();
-                }
-                if (functionMethod.getName().equals("execute")) {
-                    return "******";
-                }
-                return result;
-            }
-        );
-    }
-
+    
     public static IllegalVariableEvaluationException properPebbleException(PebbleException initialExtension) {
         if (initialExtension instanceof AttributeNotFoundException current) {
             return new IllegalVariableEvaluationException(

core/src/main/java/io/kestra/core/runners/pebble/Extension.java

@@ -168,7 +168,6 @@ public class Extension extends AbstractExtension {
         functions.put("randomPort", new RandomPortFunction());
         functions.put("fileExists", fileExistsFunction);
         functions.put("isFileEmpty", isFileEmptyFunction);
-        functions.put("nanoId", new NanoIDFunction());
         functions.put("tasksWithState", new TasksWithStateFunction());
         functions.put(HttpFunction.NAME, httpFunction);
         return functions;

core/src/main/java/io/kestra/core/runners/pebble/PebbleEngineFactory.java

@@ -0,0 +1,118 @@
+package io.kestra.core.runners.pebble;
+
+import io.kestra.core.runners.VariableRenderer;
+import io.kestra.core.runners.pebble.functions.RenderingFunctionInterface;
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.core.annotation.Nullable;
+import io.pebbletemplates.pebble.PebbleEngine;
+import io.pebbletemplates.pebble.extension.Extension;
+import io.pebbletemplates.pebble.extension.Function;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Proxy;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Singleton
+public class PebbleEngineFactory {
+    
+    private final ApplicationContext applicationContext;
+    private final VariableRenderer.VariableConfiguration variableConfiguration;
+    
+    @Inject
+    public PebbleEngineFactory(ApplicationContext applicationContext, @Nullable VariableRenderer.VariableConfiguration variableConfiguration) {
+        this.applicationContext = applicationContext;
+        this.variableConfiguration = variableConfiguration;
+    }
+    
+    public PebbleEngine create() {
+        PebbleEngine.Builder builder = newPebbleEngineBuilder();
+        this.applicationContext.getBeansOfType(Extension.class).forEach(builder::extension);
+        return builder.build();
+    }
+    
+    public PebbleEngine createWithMaskedFunctions(VariableRenderer renderer, final List<String> functionsToMask) {
+        
+        PebbleEngine.Builder builder = newPebbleEngineBuilder();
+        
+        this.applicationContext.getBeansOfType(Extension.class).stream()
+            .map(e -> functionsToMask.stream().anyMatch(fun -> e.getFunctions().containsKey(fun))
+                ? extensionWithMaskedFunctions(renderer, e, functionsToMask)
+                : e)
+            .forEach(builder::extension);
+        
+        return builder.build();
+    }
+    
+    private PebbleEngine.Builder newPebbleEngineBuilder() {
+        PebbleEngine.Builder builder = new PebbleEngine.Builder()
+            .registerExtensionCustomizer(ExtensionCustomizer::new)
+            .strictVariables(true)
+            .cacheActive(this.variableConfiguration.getCacheEnabled())
+            .newLineTrimming(false)
+            .autoEscaping(false);
+        
+        if (this.variableConfiguration.getCacheEnabled()) {
+            builder = builder.templateCache(new PebbleLruCache(this.variableConfiguration.getCacheSize()));
+        }
+        return builder;
+    }
+    
+    private Extension extensionWithMaskedFunctions(VariableRenderer renderer, Extension initialExtension, List<String> maskedFunctions) {
+        return (Extension) Proxy.newProxyInstance(
+            initialExtension.getClass().getClassLoader(),
+            new Class[]{Extension.class},
+            (proxy, method, methodArgs) -> {
+                if (method.getName().equals("getFunctions")) {
+                    return initialExtension.getFunctions().entrySet().stream()
+                        .map(entry -> {
+                            if (maskedFunctions.contains(entry.getKey())) {
+                                return Map.entry(entry.getKey(), this.maskedFunctionProxy(entry.getValue()));
+                            } else if (RenderingFunctionInterface.class.isAssignableFrom(entry.getValue().getClass())) {
+                                return Map.entry(entry.getKey(), this.variableRendererProxy(renderer, entry.getValue()));
+                            }
+                            
+                            return entry;
+                        }).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+                }
+                
+                return method.invoke(initialExtension, methodArgs);
+            }
+        );
+    }
+    
+    private Function variableRendererProxy(VariableRenderer renderer, Function initialFunction) {
+        return (Function) Proxy.newProxyInstance(
+            initialFunction.getClass().getClassLoader(),
+            new Class[]{Function.class, RenderingFunctionInterface.class},
+            (functionProxy, functionMethod, functionArgs) -> {
+                if (functionMethod.getName().equals("variableRenderer")) {
+                    return renderer;
+                }
+                return functionMethod.invoke(initialFunction, functionArgs);
+            }
+        );
+    }
+    
+    private Function maskedFunctionProxy(Function initialFunction) {
+        return (Function) Proxy.newProxyInstance(
+            initialFunction.getClass().getClassLoader(),
+            new Class[]{Function.class},
+            (functionProxy, functionMethod, functionArgs) -> {
+                Object result;
+                try {
+                    result = functionMethod.invoke(initialFunction, functionArgs);
+                } catch (InvocationTargetException e) {
+                    throw e.getCause();
+                }
+                if (functionMethod.getName().equals("execute")) {
+                    return "******";
+                }
+                return result;
+            }
+        );
+    }
+}

core/src/main/java/io/kestra/core/runners/pebble/filters/TimestampMicroFilter.java

@@ -30,6 +30,6 @@ public class TimestampMicroFilter extends AbstractDate implements Filter {
         ZoneId zoneId = zoneId(timeZone);
         ZonedDateTime date = convert(input, zoneId, existingFormat);
 
-        return String.valueOf(TimeUnit.SECONDS.toMicros(date.toEpochSecond()) + TimeUnit.NANOSECONDS.toMicros(date.getNano()));
+        return String.valueOf(TimeUnit.SECONDS.toNanos(date.toEpochSecond()) + TimeUnit.NANOSECONDS.toMicros(date.getNano()));
     }
 }

core/src/main/java/io/kestra/core/runners/pebble/functions/HttpFunction.java

@@ -5,8 +5,6 @@ import io.kestra.core.http.HttpRequest;
 import io.kestra.core.http.HttpResponse;
 import io.kestra.core.http.client.HttpClient;
 import io.kestra.core.http.client.HttpClientException;
-import io.kestra.core.http.client.HttpClientRequestException;
-import io.kestra.core.http.client.HttpClientResponseException;
 import io.kestra.core.http.client.configurations.HttpConfiguration;
 import io.kestra.core.runners.RunContext;
 import io.kestra.core.runners.RunContextFactory;
@@ -103,15 +101,8 @@ public class HttpFunction<T> implements Function {
         try (HttpClient httpClient = new HttpClient(runContext, httpConfiguration)) {
             HttpResponse<Object> response = httpClient.request(httpRequest, Object.class);
             return response.getBody();
-        } catch (HttpClientResponseException e) {
-            if (e.getResponse() != null) {
-                String msg = "Failed to execute HTTP Request, server respond with status " + e.getResponse().getStatus().getCode() + " : " + e.getResponse().getStatus().getReason();
-                throw new PebbleException(e, msg , lineNumber, self.getName());
-            } else {
-                throw new PebbleException( e, "Failed to execute HTTP request ", lineNumber, self.getName());
-            }
-        } catch(HttpClientException | IllegalVariableEvaluationException | IOException e ) {
-            throw new PebbleException( e, "Failed to execute HTTP request ", lineNumber, self.getName());
+        } catch (HttpClientException | IllegalVariableEvaluationException | IOException e) {
+            throw new PebbleException(e, "Unable to execute HTTP request", lineNumber, self.getName());
         }
     }
 

core/src/main/java/io/kestra/core/runners/pebble/functions/NanoIDFunction.java

@@ -1,66 +0,0 @@
-package io.kestra.core.runners.pebble.functions;
-
-import io.pebbletemplates.pebble.error.PebbleException;
-import io.pebbletemplates.pebble.extension.Function;
-import io.pebbletemplates.pebble.template.EvaluationContext;
-import io.pebbletemplates.pebble.template.PebbleTemplate;
-
-import java.security.SecureRandom;
-import java.util.List;
-import java.util.Map;
-
-public class NanoIDFunction implements Function {
-
-    private static final int DEFAULT_LENGTH = 21;
-    private static final char[] DEFAULT_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_".toCharArray();
-    private static final SecureRandom secureRandom = new SecureRandom();
-
-    private static final String LENGTH = "length";
-    private static final String ALPHABET = "alphabet";
-
-    private static final int MAX_LENGTH = 1000;
-
-    @Override
-    public Object execute(
-        Map<String, Object> args, PebbleTemplate self, EvaluationContext context, int lineNumber) {
-        int length = DEFAULT_LENGTH;
-        if (args.containsKey(LENGTH) && (args.get(LENGTH) instanceof Long)) {
-            length = parseLength(args, self, lineNumber);
-        }
-        char[] alphabet = DEFAULT_ALPHABET;
-        if (args.containsKey(ALPHABET) && (args.get(ALPHABET) instanceof String)) {
-            alphabet = ((String) args.get(ALPHABET)).toCharArray();
-        }
-        return createNanoID(length, alphabet);
-    }
-
-    private static int parseLength(Map<String, Object> args, PebbleTemplate self, int lineNumber) {
-        var value = (Long) args.get(LENGTH);
-        if(value > MAX_LENGTH) {
-            throw new PebbleException(
-                null,
-                "The 'nanoId()' function field 'length' must be lower than: " + MAX_LENGTH,
-                lineNumber,
-                self.getName());
-        }
-        return Math.toIntExact(value);
-    }
-
-    @Override
-    public List<String> getArgumentNames() {
-        return List.of(LENGTH,ALPHABET);
-    }
-
-    String createNanoID(int length, char[] alphabet){
-        final char[] data = new char[length];
-        final byte[] bytes = new byte[length];
-        final int mask = alphabet.length-1;
-        secureRandom.nextBytes(bytes);
-        for (int i = 0; i < length; ++i) {
-            data[i] = alphabet[bytes[i] & mask];
-        }
-        return String.valueOf(data);
-    }
-
-
-}

core/src/main/java/io/kestra/core/serializers/FileSerde.java

@@ -180,13 +180,23 @@ public final class FileSerde {
     }
 
     private static <T> MappingIterator<T> createMappingIterator(ObjectMapper objectMapper, Reader reader, TypeReference<T> type) throws IOException {
+        // See https://github.com/FasterXML/jackson-dataformats-binary/issues/493
+        // There is a limitation with the MappingIterator that cannot differentiate between an array of things (of whatever shape)
+        // and a sequence/stream of things (of Array shape).
+        // To work around that, we need to create a JsonParser and advance to the first token.
         try (var parser = objectMapper.createParser(reader)) {
+            parser.nextToken();
             return objectMapper.readerFor(type).readValues(parser);
         }
     }
 
     private static <T> MappingIterator<T> createMappingIterator(ObjectMapper objectMapper, Reader reader, Class<T> type) throws IOException {
+        // See https://github.com/FasterXML/jackson-dataformats-binary/issues/493
+        // There is a limitation with the MappingIterator that cannot differentiate between an array of things (of whatever shape)
+        // and a sequence/stream of things (of Array shape).
+        // To work around that, we need to create a JsonParser and advance to the first token.
         try (var parser = objectMapper.createParser(reader)) {
+            parser.nextToken();
             return objectMapper.readerFor(type).readValues(parser);
         }
     }

core/src/main/java/io/kestra/core/services/ExecutionService.java

@@ -56,8 +56,7 @@ import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import static io.kestra.core.utils.Rethrow.throwFunction;
-import static io.kestra.core.utils.Rethrow.throwPredicate;
+import static io.kestra.core.utils.Rethrow.*;
 
 @Singleton
 @Slf4j
@@ -431,7 +430,8 @@ public class ExecutionService {
         @Nullable String flowId,
         @Nullable ZonedDateTime startDate,
         @Nullable ZonedDateTime endDate,
-        @Nullable List<State.Type> state
+        @Nullable List<State.Type> state,
+        int batchSize
     ) throws IOException {
         PurgeResult purgeResult = this.executionRepository
             .find(
@@ -448,24 +448,27 @@ public class ExecutionService {
                 null,
                 true
             )
-            .map(throwFunction(execution -> {
+            .buffer(batchSize)
+            .map(throwFunction(executions -> {
                 PurgeResult.PurgeResultBuilder<?, ?> builder = PurgeResult.builder();
 
                 if (purgeExecution) {
-                    builder.executionsCount(this.executionRepository.purge(execution));
+                    builder.executionsCount(this.executionRepository.purge(executions));
                 }
 
                 if (purgeLog) {
-                    builder.logsCount(this.logRepository.purge(execution));
+                    builder.logsCount(this.logRepository.purge(executions));
                 }
 
                 if (purgeMetric) {
-                    builder.metricsCount(this.metricRepository.purge(execution));
+                    builder.metricsCount(this.metricRepository.purge(executions));
                 }
 
                 if (purgeStorage) {
-                    URI uri = StorageContext.forExecution(execution).getExecutionStorageURI(StorageContext.KESTRA_SCHEME);
-                    builder.storagesCount(storageInterface.deleteByPrefix(execution.getTenantId(), execution.getNamespace(), uri).size());
+                    executions.forEach(throwConsumer(execution -> {
+                        URI uri = StorageContext.forExecution(execution).getExecutionStorageURI(StorageContext.KESTRA_SCHEME);
+                        builder.storagesCount(storageInterface.deleteByPrefix(execution.getTenantId(), execution.getNamespace(), uri).size());
+                    }));
                 }
 
                 return (PurgeResult) builder.build();
@@ -715,8 +718,9 @@ public class ExecutionService {
         } else {
             newExecution = execution.withState(killingOrAfterKillState);
         }
-
-        eventPublisher.publishEvent(new CrudEvent<>(newExecution, execution, CrudEventType.UPDATE));
+        
+        // Because this method is expected to be called by the Executor we can return the Execution 
+        // immediately without publishing a CrudEvent like it's done on pause/resume method.
         return newExecution;
     }
     public Execution kill(Execution execution, FlowInterface flow) {

core/src/main/java/io/kestra/core/services/SkipExecutionService.java

@@ -1,40 +1,42 @@
-package io.kestra.executor;
+package io.kestra.core.services;
 
 import com.google.common.annotations.VisibleForTesting;
 import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.executions.TaskRun;
 import jakarta.annotation.Nullable;
 import jakarta.inject.Singleton;
-import lombok.extern.slf4j.Slf4j;
 
 import java.util.Collections;
 import java.util.List;
-import java.util.Objects;
 
 @Singleton
-@Slf4j
 public class SkipExecutionService {
     private volatile List<String> skipExecutions = Collections.emptyList();
     private volatile List<FlowId> skipFlows = Collections.emptyList();
     private volatile List<NamespaceId> skipNamespaces = Collections.emptyList();
     private volatile List<String> skipTenants = Collections.emptyList();
+    private volatile List<String> skipIndexerRecords = Collections.emptyList();
 
     public synchronized void setSkipExecutions(List<String> skipExecutions) {
         this.skipExecutions = skipExecutions == null ? Collections.emptyList() : skipExecutions;
     }
 
     public synchronized void setSkipFlows(List<String> skipFlows) {
-        this.skipFlows = skipFlows == null ? Collections.emptyList() : skipFlows.stream().map(FlowId::from).filter(Objects::nonNull).toList();
+        this.skipFlows = skipFlows == null ? Collections.emptyList() : skipFlows.stream().map(FlowId::from).toList();
     }
 
     public synchronized void setSkipNamespaces(List<String> skipNamespaces) {
-        this.skipNamespaces = skipNamespaces == null ? Collections.emptyList() : skipNamespaces.stream().map(NamespaceId::from).filter(Objects::nonNull).toList();
+        this.skipNamespaces = skipNamespaces == null ? Collections.emptyList() : skipNamespaces.stream().map(NamespaceId::from).toList();
     }
 
     public synchronized void setSkipTenants(List<String> skipTenants) {
         this.skipTenants = skipTenants == null ? Collections.emptyList() : skipTenants;
     }
 
+    public synchronized void setSkipIndexerRecords(List<String> skipIndexerRecords) {
+        this.skipIndexerRecords = skipIndexerRecords == null ? Collections.emptyList() : skipIndexerRecords;
+    }
+
     /**
      * Warning: this method didn't check the flow, so it must be used only when neither of the others can be used.
      */
@@ -50,6 +52,14 @@ public class SkipExecutionService {
         return skipExecution(taskRun.getTenantId(), taskRun.getNamespace(), taskRun.getFlowId(), taskRun.getExecutionId());
     }
 
+    /**
+     * Skip an indexer records based on its key.
+     * @param key the record key as computed by <code>QueueService.key(record)</code>, can be null
+     */
+    public boolean skipIndexerRecord(@Nullable String key) {
+        return key != null && skipIndexerRecords.contains(key);
+    }
+
     @VisibleForTesting
     boolean skipExecution(String tenant, String namespace, String flow, String executionId) {
         return (tenant != null && skipTenants.contains(tenant)) ||
@@ -63,31 +73,19 @@ public class SkipExecutionService {
     }
 
     record FlowId(String tenant, String namespace, String flow) {
-        static @Nullable FlowId from(String flowId) {
+        static FlowId from(String flowId) {
             String[] parts = SkipExecutionService.splitIdParts(flowId);
             if (parts.length == 3) {
                 return new FlowId(parts[0], parts[1], parts[2]);
-            } else if (parts.length == 2) {
-                return new FlowId(null, parts[0], parts[1]);
-            } else {
-                log.error("Invalid flow skip with values: '{}'", flowId);
             }
-
-            return null;
+            return new FlowId(null, parts[0], parts[1]);
         }
     };
 
     record NamespaceId(String tenant, String namespace) {
-        static @Nullable NamespaceId from(String namespaceId) {
+        static NamespaceId from(String namespaceId) {
             String[] parts = SkipExecutionService.splitIdParts(namespaceId);
-
-            if (parts.length == 2) {
-                return new NamespaceId(parts[0], parts[1]);
-            } else {
-                log.error("Invalid namespace skip with values:'{}'", namespaceId);
-            }
-
-            return null;
+            return new NamespaceId(parts[0], parts[1]);
         }
     };
 }

core/src/main/java/io/kestra/core/utils/Version.java

@@ -32,84 +32,48 @@ public class Version implements Comparable<Version> {
      * @param version   the version.
      * @return          a new {@link Version} instance.
      */
-    public static Version of(final Object version) {
+    public static Version of(String version) {
 
-        if (Objects.isNull(version)) {
-            throw new IllegalArgumentException("Invalid version, cannot parse null version");
-        }
-        
-        String strVersion = version.toString();
-        
-        if (strVersion.startsWith("v")) {
-            strVersion = strVersion.substring(1);
+        if (version.startsWith("v")) {
+            version = version.substring(1);
         }
 
-        int qualifier = strVersion.indexOf("-");
+        int qualifier = version.indexOf("-");
 
         final String[] versions = qualifier > 0 ?
-            strVersion.substring(0, qualifier).split("\\.") :
-            strVersion.split("\\.");
+            version.substring(0, qualifier).split("\\.") :
+            version.split("\\.");
         try {
             final int majorVersion = Integer.parseInt(versions[0]);
-            final Integer minorVersion = versions.length > 1 ? Integer.parseInt(versions[1]) : null;
-            final Integer incrementalVersion = versions.length > 2 ? Integer.parseInt(versions[2]) : null;
+            final int minorVersion = versions.length > 1 ? Integer.parseInt(versions[1]) : 0;
+            final int incrementalVersion = versions.length > 2 ? Integer.parseInt(versions[2]) : 0;
 
             return new Version(
                 majorVersion,
                 minorVersion,
                 incrementalVersion,
-                qualifier > 0 ? strVersion.substring(qualifier + 1) : null,
-                strVersion
+                qualifier > 0 ? version.substring(qualifier + 1) : null,
+                version
             );
         } catch (NumberFormatException e) {
             throw new IllegalArgumentException("Invalid version, cannot parse '" + version + "'");
         }
     }
-    
+
     /**
-     * Resolves the most appropriate stable version from a collection, based on a given input version.
-     * <p>
-     * The matching rules are:
-     * <ul>
-     *   <li>If {@code from} specifies only a major version (e.g. {@code 1}), return the latest stable version
-     *       with the same major (e.g. {@code 1.2.3}).</li>
-     *   <li>If {@code from} specifies a major and minor version only (e.g. {@code 1.2}), return the latest
-     *       stable version with the same major and minor (e.g. {@code 1.2.3}).</li>
-     *   <li>If {@code from} specifies a full version with major, minor, and patch (e.g. {@code 1.2.2}),
-     *       then only return it if it is exactly present (and stable) in {@code versions}.
-     *       No "upgrade" is performed in this case.</li>
-     *   <li>If no suitable version is found, returns {@code null}.</li>
-     * </ul>
+     * Static helper method for returning the most recent stable version for a current {@link Version}.
      *
-     * @param from     the reference version (may specify only major, or major+minor, or major+minor+patch).
-     * @param versions the collection of candidate versions to resolve against.
-     * @return the best matching stable version, or {@code null} if none match.
+     * @param from     the current version.
+     * @param versions the list of version.
+     *
+     * @return the last stable version.
      */
     public static Version getStable(final Version from, final Collection<Version> versions) {
-        // Case 1: "from" is only a major (e.g. 1)
-        if (from.hasOnlyMajor()) {
-            List<Version> sameMajor = versions.stream()
-                .filter(v -> v.majorVersion() == from.majorVersion())
-                .toList();
-            return sameMajor.isEmpty() ? null : Version.getLatest(sameMajor);
-        }
-        
-        // Case 2: "from" is major+minor only (e.g. 1.2)
-        if (from.hasMajorAndMinorOnly()) {
-            List<Version> sameMinor = versions.stream()
-                .filter(v -> v.majorVersion() == from.majorVersion()
-                    && v.minorVersion() == from.minorVersion())
-                .toList();
-            return sameMinor.isEmpty() ? null : Version.getLatest(sameMinor);
-        }
-        
-        // Case 3: "from" is full version (major+minor+patch)
-        if (versions.contains(from)) {
-            return from;
-        }
-        
-        // No match
-        return null;
+        List<Version> compatibleVersions = versions.stream()
+            .filter(v -> v.majorVersion() == from.majorVersion() && v.minorVersion() == from.minorVersion())
+            .toList();
+        if (compatibleVersions.isEmpty()) return null;
+        return Version.getLatest(compatibleVersions);
     }
 
     /**
@@ -159,8 +123,8 @@ public class Version implements Comparable<Version> {
     }
 
     private final int majorVersion;
-    private final Integer minorVersion;
-    private final Integer patchVersion;
+    private final int minorVersion;
+    private final int incrementalVersion;
     private final Qualifier qualifier;
 
     private final String originalVersion;
@@ -170,14 +134,14 @@ public class Version implements Comparable<Version> {
      *
      * @param majorVersion          the major version (must be superior or equal to 0).
      * @param minorVersion          the minor version (must be superior or equal to 0).
-     * @param patchVersion    the incremental version (must be superior or equal to 0).
+     * @param incrementalVersion    the incremental version (must be superior or equal to 0).
      * @param qualifier             the qualifier.
      */
     public Version(final int majorVersion,
                    final int minorVersion,
-                   final int patchVersion,
+                   final int incrementalVersion,
                    final String qualifier) {
-        this(majorVersion, minorVersion, patchVersion, qualifier, null);
+        this(majorVersion, minorVersion, incrementalVersion, qualifier, null);
     }
 
     /**
@@ -185,25 +149,25 @@ public class Version implements Comparable<Version> {
      *
      * @param majorVersion          the major version (must be superior or equal to 0).
      * @param minorVersion          the minor version (must be superior or equal to 0).
-     * @param patchVersion    the incremental version (must be superior or equal to 0).
+     * @param incrementalVersion    the incremental version (must be superior or equal to 0).
      * @param qualifier             the qualifier.
      * @param originalVersion       the original string version.
      */
-    private Version(final Integer majorVersion,
-                    final Integer minorVersion,
-                    final Integer patchVersion,
+    private Version(final int majorVersion,
+                    final int minorVersion,
+                    final int incrementalVersion,
                     final String qualifier,
                     final String originalVersion) {
         this.majorVersion =  requirePositive(majorVersion, "major");
         this.minorVersion = requirePositive(minorVersion, "minor");
-        this.patchVersion = requirePositive(patchVersion, "incremental");
+        this.incrementalVersion = requirePositive(incrementalVersion, "incremental");
         this.qualifier = qualifier != null ? new Qualifier(qualifier) : null;
         this.originalVersion = originalVersion;
     }
 
 
-    private static Integer requirePositive(Integer version, final String message) {
-        if (version != null && version < 0) {
+    private static int requirePositive(int version, final String message) {
+        if (version < 0) {
             throw new IllegalArgumentException(String.format("The '%s' version must super or equal to 0", message));
         }
         return version;
@@ -214,11 +178,11 @@ public class Version implements Comparable<Version> {
     }
 
     public int minorVersion() {
-        return minorVersion != null ? minorVersion : 0;
+        return minorVersion;
     }
 
-    public int patchVersion() {
-        return patchVersion != null ? patchVersion : 0;
+    public int incrementalVersion() {
+        return incrementalVersion;
     }
 
     public Qualifier qualifier() {
@@ -233,9 +197,9 @@ public class Version implements Comparable<Version> {
         if (this == o) return true;
         if (!(o instanceof Version)) return false;
         Version version = (Version) o;
-        return Objects.equals(majorVersion,version.majorVersion) &&
-            Objects.equals(minorVersion, version.minorVersion) &&
-            Objects.equals(patchVersion,version.patchVersion) &&
+        return majorVersion == version.majorVersion &&
+            minorVersion == version.minorVersion &&
+            incrementalVersion == version.incrementalVersion &&
             Objects.equals(qualifier, version.qualifier);
     }
 
@@ -244,7 +208,7 @@ public class Version implements Comparable<Version> {
      */
     @Override
     public int hashCode() {
-        return Objects.hash(majorVersion, minorVersion, patchVersion, qualifier);
+        return Objects.hash(majorVersion, minorVersion, incrementalVersion, qualifier);
     }
 
     /**
@@ -254,7 +218,7 @@ public class Version implements Comparable<Version> {
     public String toString() {
         if (originalVersion != null) return originalVersion;
 
-        String version =  majorVersion + "." + minorVersion + "." + patchVersion;
+        String version =  majorVersion + "." + minorVersion + "." + incrementalVersion;
         return (qualifier != null) ? version +"-" + qualifier : version;
     }
 
@@ -274,7 +238,7 @@ public class Version implements Comparable<Version> {
             return compareMinor;
         }
 
-        int compareIncremental = Integer.compare(that.patchVersion, this.patchVersion);
+        int compareIncremental = Integer.compare(that.incrementalVersion, this.incrementalVersion);
         if (compareIncremental != 0) {
             return compareIncremental;
         }
@@ -289,21 +253,6 @@ public class Version implements Comparable<Version> {
 
         return this.qualifier.compareTo(that.qualifier);
     }
-    
-    
-    /**
-     * @return true if only major is specified (e.g. "1")
-     */
-    private boolean hasOnlyMajor() {
-        return minorVersion == null && patchVersion == null;
-    }
-    
-    /**
-     * @return true if major+minor are specified, but no patch (e.g. "1.2")
-     */
-    private boolean hasMajorAndMinorOnly() {
-        return minorVersion != null && patchVersion == null;
-    }
 
     /**
      * Checks whether this version is before the given one.

core/src/main/java/io/kestra/core/utils/VersionProvider.java

@@ -46,19 +46,16 @@ public class VersionProvider {
         this.date = loadTime(gitProperties);
         this.version = loadVersion(buildProperties, gitProperties);
 
-        // check the version in the settings and update if needed, we didn't use it would allow us to detect incompatible update later if needed
-        settingRepository.ifPresent(
-            settingRepositoryInterface -> persistVersion(settingRepositoryInterface, version));
-    }
-
-    private static synchronized void persistVersion(SettingRepositoryInterface settingRepositoryInterface, String version) {
-        Optional<Setting> versionSetting = settingRepositoryInterface.findByKey(Setting.INSTANCE_VERSION);
-        if (versionSetting.isEmpty() || !versionSetting.get().getValue().equals(version)) {
-            settingRepositoryInterface.save(Setting.builder()
-                .key(Setting.INSTANCE_VERSION)
-                .value(version)
-                .build()
-            );
+        // check the version in the settings and update if needed, we did't use it would allow us to detect incompatible update later if needed
+        if (settingRepository.isPresent()) {
+            Optional<Setting> versionSetting = settingRepository.get().findByKey(Setting.INSTANCE_VERSION);
+            if (versionSetting.isEmpty() || !versionSetting.get().getValue().equals(this.version)) {
+                settingRepository.get().save(Setting.builder()
+                    .key(Setting.INSTANCE_VERSION)
+                    .value(this.version)
+                    .build()
+                );
+            }
         }
     }
 

core/src/main/java/io/kestra/core/validations/validator/FlowValidator.java

@@ -63,7 +63,7 @@ public class FlowValidator implements ConstraintValidator<FlowValidation, Flow>
 
         List<String> violations = new ArrayList<>();
 
-        if (RESERVED_FLOW_IDS.contains(value.getId())) {
+        if (value.getId() != null && RESERVED_FLOW_IDS.contains(value.getId())) {
             violations.add("Flow id is a reserved keyword: " + value.getId() + ". List of reserved keywords: " + String.join(", ", RESERVED_FLOW_IDS));
         }
 

core/src/main/java/io/kestra/plugin/core/execution/Labels.java

@@ -127,24 +127,9 @@ public class Labels extends Task implements ExecutionUpdatableTask {
         }
 
         // check for system labels: none can be passed at runtime
-        Optional<Map.Entry<String, String>> systemLabel = labelsAsMap.entrySet().stream()
-            .filter(entry -> entry.getKey().startsWith(SYSTEM_PREFIX))
-            .findFirst();
-        if (systemLabel.isPresent()) {
-            throw new IllegalArgumentException(
-                "System labels can only be set by Kestra itself, offending label: " +
-                systemLabel.get().getKey() + "=" + systemLabel.get().getValue()
-            );
-        }
-
-        // check for empty label values
-        Optional<Map.Entry<String, String>> emptyValue = labelsAsMap.entrySet().stream()
-            .filter(entry -> entry.getValue().isEmpty())
-            .findFirst();
-        if (emptyValue.isPresent()) {
-            throw new IllegalArgumentException(
-                "Label values cannot be empty, offending label: " + emptyValue.get().getKey()
-            );
+        Optional<Map.Entry<String, String>> first = labelsAsMap.entrySet().stream().filter(entry -> entry.getKey().startsWith(SYSTEM_PREFIX)).findFirst();
+        if (first.isPresent()) {
+            throw new IllegalArgumentException("System labels can only be set by Kestra itself, offending label: " + first.get().getKey() + "=" + first.get().getValue());
         }
 
         Map<String, String> newLabels = ListUtils.emptyOnNull(execution.getLabels()).stream()
@@ -155,7 +140,6 @@ public class Labels extends Task implements ExecutionUpdatableTask {
         newLabels.putAll(labelsAsMap);
 
         return execution.withLabels(newLabels.entrySet().stream()
-            .filter(Label.getEntryNotEmptyPredicate())
             .map(entry -> new Label(
                 entry.getKey(),
                 entry.getValue()

core/src/main/java/io/kestra/plugin/core/execution/PurgeExecutions.java

@@ -102,6 +102,14 @@ public class PurgeExecutions extends Task implements RunnableTask<PurgeExecution
     @Builder.Default
     private Property<Boolean> purgeStorage = Property.ofValue(true);
 
+    @Schema(
+        title = "The size of the bulk delete",
+        description = "For performance, deletion is made by batch of by default 100 executions/logs/metrics."
+    )
+    @Builder.Default
+    @NotNull
+    private Property<Integer> batchSize = Property.ofValue(100);
+
     @Override
     public PurgeExecutions.Output run(RunContext runContext) throws Exception {
         ExecutionService executionService = ((DefaultRunContext)runContext).getApplicationContext().getBean(ExecutionService.class);
@@ -124,9 +132,10 @@ public class PurgeExecutions extends Task implements RunnableTask<PurgeExecution
             flowInfo.tenantId(),
             renderedNamespace,
             runContext.render(flowId).as(String.class).orElse(null),
-            startDate != null ? ZonedDateTime.parse(runContext.render(startDate).as(String.class).orElseThrow()) : null,
+            runContext.render(startDate).as(String.class).map(ZonedDateTime::parse).orElse(null),
             ZonedDateTime.parse(runContext.render(endDate).as(String.class).orElseThrow()),
-            this.states == null ? null : runContext.render(this.states).asList(State.Type.class)
+            this.states == null ? null : runContext.render(this.states).asList(State.Type.class),
+            runContext.render(this.batchSize).as(Integer.class).orElseThrow()
         );
 
         return Output.builder()

core/src/test/java/io/kestra/core/docs/DocumentationGeneratorTest.java

@@ -21,13 +21,10 @@ import java.nio.file.Paths;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
-import org.junit.jupiter.api.parallel.Execution;
-import org.junit.jupiter.api.parallel.ExecutionMode;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 @KestraTest
-@Execution(ExecutionMode.SAME_THREAD)
 class DocumentationGeneratorTest {
     @Inject
     JsonSchemaGenerator jsonSchemaGenerator;

core/src/test/java/io/kestra/core/http/client/HttpClientTest.java

@@ -37,7 +37,6 @@ import lombok.Value;
 import org.apache.commons.io.IOUtils;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.parallel.ExecutionMode;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -68,7 +67,6 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
 
 @KestraTest
 @Testcontainers
-@org.junit.jupiter.api.parallel.Execution(ExecutionMode.SAME_THREAD)
 class HttpClientTest {
     @Inject
     private ApplicationContext applicationContext;

core/src/test/java/io/kestra/core/models/LabelTest.java

@@ -1,32 +1,19 @@
 package io.kestra.core.models;
 
-import io.kestra.core.junit.annotations.KestraTest;
-import io.kestra.core.models.validations.ModelValidator;
-import jakarta.inject.Inject;
-import jakarta.validation.ConstraintViolationException;
 import org.junit.jupiter.api.Test;
 
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-@KestraTest
 class LabelTest {
-    @Inject
-    private ModelValidator modelValidator;
 
     @Test
     void shouldGetNestedMapGivenDistinctLabels() {
         Map<String, Object> result = Label.toNestedMap(List.of(
             new Label(Label.USERNAME, "test"),
-            new Label(Label.CORRELATION_ID, "id"),
-            new Label("", "bar"),
-            new Label(null, "bar"),
-            new Label("foo", ""),
-            new Label("baz", null)
-            )
+            new Label(Label.CORRELATION_ID, "id"))
         );
 
         assertThat(result).isEqualTo(
@@ -47,18 +34,6 @@ class LabelTest {
         );
     }
 
-    @Test
-    void toNestedMapShouldIgnoreEmptyOrNull() {
-        Map<String, Object> result = Label.toNestedMap(List.of(
-            new Label("", "bar"),
-            new Label(null, "bar"),
-            new Label("foo", ""),
-            new Label("baz", null))
-        );
-
-        assertThat(result).isEmpty();
-    }
-
     @Test
     void shouldGetMapGivenDistinctLabels() {
         Map<String, String> result = Label.toMap(List.of(
@@ -84,18 +59,6 @@ class LabelTest {
         );
     }
 
-    @Test
-    void toMapShouldIgnoreEmptyOrNull() {
-        Map<String, String> result = Label.toMap(List.of(
-            new Label("", "bar"),
-            new Label(null, "bar"),
-            new Label("foo", ""),
-            new Label("baz", null))
-        );
-
-        assertThat(result).isEmpty();
-    }
-
     @Test
     void shouldDuplicateLabelsWithKeyOrderKept() {
         List<Label> result = Label.deduplicate(List.of(
@@ -110,28 +73,4 @@ class LabelTest {
             new Label(Label.CORRELATION_ID, "id")
         );
     }
-
-    @Test
-    void deduplicateShouldIgnoreEmptyAndNull() {
-        List<Label> result = Label.deduplicate(List.of(
-            new Label("", "bar"),
-            new Label(null, "bar"),
-            new Label("foo", ""),
-            new Label("baz", null))
-        );
-
-        assertThat(result).isEmpty();
-    }
-
-    @Test
-    void shouldValidateEmpty() {
-        Optional<ConstraintViolationException> validLabelResult = modelValidator.isValid(new Label("foo", "bar"));
-        assertThat(validLabelResult.isPresent()).isFalse();
-
-        Optional<ConstraintViolationException> emptyValueLabelResult = modelValidator.isValid(new Label("foo", ""));
-        assertThat(emptyValueLabelResult.isPresent()).isTrue();
-
-        Optional<ConstraintViolationException> emptyKeyLabelResult = modelValidator.isValid(new Label("", "bar"));
-        assertThat(emptyKeyLabelResult.isPresent()).isTrue();
-    }
 }

core/src/test/java/io/kestra/core/models/executions/ExecutionTest.java

@@ -13,19 +13,19 @@ import java.util.Map;
 import static org.assertj.core.api.Assertions.assertThat;
 
 class ExecutionTest {
+    private static final TaskRun.TaskRunBuilder TASK_RUN = TaskRun.builder()
+        .id("test");
 
     @Test
     void hasTaskRunJoinableTrue() {
         Execution execution = Execution.builder()
-            .taskRunList(Collections.singletonList(TaskRun.builder()
-                .id("test")
+            .taskRunList(Collections.singletonList(TASK_RUN
                 .state(new State(State.Type.RUNNING, new State()))
                 .build())
             )
             .build();
 
-        assertThat(execution.hasTaskRunJoinable(TaskRun.builder()
-            .id("test")
+        assertThat(execution.hasTaskRunJoinable(TASK_RUN
             .state(new State(State.Type.FAILED, new State()
                 .withState(State.Type.RUNNING)
             ))
@@ -36,15 +36,13 @@ class ExecutionTest {
     @Test
     void hasTaskRunJoinableSameState() {
         Execution execution = Execution.builder()
-            .taskRunList(Collections.singletonList(TaskRun.builder()
-                .id("test")
+            .taskRunList(Collections.singletonList(TASK_RUN
                 .state(new State())
                 .build())
             )
             .build();
 
-        assertThat(execution.hasTaskRunJoinable(TaskRun.builder()
-            .id("test")
+        assertThat(execution.hasTaskRunJoinable(TASK_RUN
             .state(new State())
             .build()
         )).isFalse();
@@ -53,8 +51,7 @@ class ExecutionTest {
     @Test
     void hasTaskRunJoinableFailedExecutionFromExecutor() {
         Execution execution = Execution.builder()
-            .taskRunList(Collections.singletonList(TaskRun.builder()
-                .id("test")
+            .taskRunList(Collections.singletonList(TASK_RUN
                 .state(new State(State.Type.FAILED, new State()
                     .withState(State.Type.RUNNING)
                 ))
@@ -62,8 +59,7 @@ class ExecutionTest {
             )
             .build();
 
-        assertThat(execution.hasTaskRunJoinable(TaskRun.builder()
-            .id("test")
+        assertThat(execution.hasTaskRunJoinable(TASK_RUN
             .state(new State(State.Type.RUNNING, new State()))
             .build()
         )).isFalse();
@@ -72,8 +68,7 @@ class ExecutionTest {
     @Test
     void hasTaskRunJoinableRestartFailed() {
         Execution execution = Execution.builder()
-            .taskRunList(Collections.singletonList(TaskRun.builder()
-                .id("test")
+            .taskRunList(Collections.singletonList(TASK_RUN
                 .state(new State(State.Type.CREATED, new State()
                     .withState(State.Type.RUNNING)
                     .withState(State.Type.FAILED)
@@ -82,8 +77,7 @@ class ExecutionTest {
             )
             .build();
 
-        assertThat(execution.hasTaskRunJoinable(TaskRun.builder()
-            .id("test")
+        assertThat(execution.hasTaskRunJoinable(TASK_RUN
             .state(new State(State.Type.FAILED, new State()
                 .withState(State.Type.RUNNING)
             ))
@@ -94,8 +88,7 @@ class ExecutionTest {
     @Test
     void hasTaskRunJoinableRestartSuccess() {
         Execution execution = Execution.builder()
-            .taskRunList(Collections.singletonList(TaskRun.builder()
-                .id("test")
+            .taskRunList(Collections.singletonList(TASK_RUN
                 .state(new State(State.Type.CREATED, new State()
                     .withState(State.Type.RUNNING)
                     .withState(State.Type.SUCCESS)
@@ -104,8 +97,7 @@ class ExecutionTest {
             )
             .build();
 
-        assertThat(execution.hasTaskRunJoinable(TaskRun.builder()
-            .id("test")
+        assertThat(execution.hasTaskRunJoinable(TASK_RUN
             .state(new State(State.Type.SUCCESS, new State()
                 .withState(State.Type.RUNNING)
                 .withState(State.Type.SUCCESS)
@@ -117,8 +109,7 @@ class ExecutionTest {
     @Test
     void hasTaskRunJoinableAfterRestart() {
         Execution execution = Execution.builder()
-            .taskRunList(Collections.singletonList(TaskRun.builder()
-                .id("test")
+            .taskRunList(Collections.singletonList(TASK_RUN
                 .state(new State(State.Type.CREATED, new State()
                     .withState(State.Type.RUNNING)
                     .withState(State.Type.FAILED)
@@ -127,8 +118,7 @@ class ExecutionTest {
             )
             .build();
 
-        assertThat(execution.hasTaskRunJoinable(TaskRun.builder()
-            .id("test")
+        assertThat(execution.hasTaskRunJoinable(TASK_RUN
             .state(new State(State.Type.SUCCESS, new State()
                 .withState(State.Type.RUNNING)
                 .withState(State.Type.FAILED)

core/src/test/java/io/kestra/core/models/hierarchies/FlowGraphTest.java

@@ -7,11 +7,12 @@ import io.kestra.core.junit.annotations.ExecuteFlow;
 import io.kestra.core.junit.annotations.KestraTest;
 import io.kestra.core.junit.annotations.LoadFlows;
 import io.kestra.core.models.executions.Execution;
+import io.kestra.core.models.flows.Flow;
 import io.kestra.core.models.flows.FlowWithSource;
 import io.kestra.core.models.triggers.Trigger;
 import io.kestra.core.queues.QueueException;
 import io.kestra.core.repositories.TriggerRepositoryInterface;
-import io.kestra.core.runners.TestRunnerUtils;
+import io.kestra.core.runners.RunnerUtils;
 import io.kestra.core.serializers.YamlParser;
 import io.kestra.core.services.GraphService;
 import io.kestra.core.utils.GraphUtils;
@@ -44,7 +45,7 @@ class FlowGraphTest {
     private TriggerRepositoryInterface triggerRepositoryInterface;
 
     @Inject
-    private TestRunnerUtils runnerUtils;
+    private RunnerUtils runnerUtils;
 
     @Test
     void simple() throws IllegalVariableEvaluationException, IOException {
@@ -260,10 +261,10 @@ class FlowGraphTest {
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/task-flow.yaml",
-        "flows/valids/switch.yaml"}, tenantId = "tenant1")
+    @LoadFlows({"flows/valids/task-flow.yaml",
+        "flows/valids/switch.yaml"})
     void subflow() throws IllegalVariableEvaluationException, IOException, FlowProcessingException {
-        FlowWithSource flow = this.parse("flows/valids/task-flow.yaml", "tenant1");
+        FlowWithSource flow = this.parse("flows/valids/task-flow.yaml");
         FlowGraph flowGraph = GraphUtils.flowGraph(flow, null);
 
         assertThat(flowGraph.getNodes().size()).isEqualTo(6);
@@ -292,15 +293,15 @@ class FlowGraphTest {
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/task-flow-dynamic.yaml",
-        "flows/valids/switch.yaml"}, tenantId = "tenant2")
+    @LoadFlows({"flows/valids/task-flow-dynamic.yaml",
+        "flows/valids/switch.yaml"})
     void dynamicIdSubflow() throws IllegalVariableEvaluationException, TimeoutException, QueueException, IOException, FlowProcessingException {
-        FlowWithSource flow = this.parse("flows/valids/task-flow-dynamic.yaml", "tenant2").toBuilder().revision(1).build();
+        FlowWithSource flow = this.parse("flows/valids/task-flow-dynamic.yaml").toBuilder().revision(1).build();
 
         IllegalArgumentException illegalArgumentException = Assertions.assertThrows(IllegalArgumentException.class, () -> graphService.flowGraph(flow, Collections.singletonList("root.launch")));
         assertThat(illegalArgumentException.getMessage()).isEqualTo("Can't expand subflow task 'launch' because namespace and/or flowId contains dynamic values. This can only be viewed on an execution.");
 
-        Execution execution = runnerUtils.runOne("tenant2", "io.kestra.tests", "task-flow-dynamic", 1, (f, e) -> Map.of(
+        Execution execution = runnerUtils.runOne(MAIN_TENANT, "io.kestra.tests", "task-flow-dynamic", 1, (f, e) -> Map.of(
             "namespace", f.getNamespace(),
             "flowId", "switch"
         ));
@@ -372,17 +373,13 @@ class FlowGraphTest {
     }
 
     private FlowWithSource parse(String path) throws IOException {
-        return parse(path, MAIN_TENANT);
-    }
-
-    private FlowWithSource parse(String path, String tenantId) throws IOException {
         URL resource = TestsUtils.class.getClassLoader().getResource(path);
         assert resource != null;
 
         File file = new File(resource.getFile());
 
         return YamlParser.parse(file, FlowWithSource.class).toBuilder()
-            .tenantId(tenantId)
+            .tenantId(MAIN_TENANT)
             .source(Files.readString(file.toPath()))
             .build();
     }

core/src/test/java/io/kestra/core/models/property/URIFetcherTest.java

@@ -4,7 +4,6 @@ import io.kestra.core.junit.annotations.KestraTest;
 import io.kestra.core.runners.*;
 import io.kestra.core.storages.StorageContext;
 import io.kestra.core.storages.StorageInterface;
-import io.kestra.core.utils.IdUtils;
 import jakarta.inject.Inject;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
@@ -85,9 +84,8 @@ class URIFetcherTest {
 
     @Test
     void shouldFetchFromNsfile() throws IOException {
-        String namespace = IdUtils.create();
-        URI uri = createNsFile(namespace, false);
-        RunContext runContext = runContextFactory.of(Map.of("flow", Map.of("namespace", namespace)));
+        URI uri = createNsFile(false);
+        RunContext runContext = runContextFactory.of(Map.of("flow", Map.of("namespace", "namespace")));
 
         try (var fetch = URIFetcher.of(uri).fetch(runContext)) {
             String fetchedContent = new String(fetch.readAllBytes());
@@ -97,8 +95,7 @@ class URIFetcherTest {
 
     @Test
     void shouldFetchFromNsfileFromOtherNs() throws IOException {
-        String namespace = IdUtils.create();
-        URI uri = createNsFile(namespace, true);
+        URI uri = createNsFile(true);
         RunContext runContext = runContextFactory.of(Map.of("flow", Map.of("namespace", "other")));
 
         try (var fetch = URIFetcher.of(uri).fetch(runContext)) {
@@ -142,7 +139,8 @@ class URIFetcherTest {
         );
     }
 
-    private URI createNsFile(String namespace, boolean nsInAuthority) throws IOException {
+    private URI createNsFile(boolean nsInAuthority) throws IOException {
+        String namespace = "namespace";
         String filePath = "file.txt";
         storage.createDirectory(MAIN_TENANT, namespace, URI.create(StorageContext.namespaceFilePrefix(namespace)));
         storage.put(MAIN_TENANT, namespace, URI.create(StorageContext.namespaceFilePrefix(namespace) + "/" + filePath), new ByteArrayInputStream("Hello World".getBytes()));

core/src/test/java/io/kestra/core/models/tasks/runners/ScriptServiceTest.java

@@ -10,7 +10,6 @@ import io.kestra.core.models.tasks.Task;
 import io.kestra.core.runners.RunContext;
 import io.kestra.core.runners.RunContextFactory;
 import io.kestra.core.junit.annotations.KestraTest;
-import io.kestra.core.utils.IdUtils;
 import jakarta.inject.Inject;
 import org.junit.jupiter.api.Test;
 
@@ -34,15 +33,17 @@ class ScriptServiceTest {
 
     @Test
     void replaceInternalStorage() throws IOException {
-        String tenant = IdUtils.create();
-        var runContext = runContextFactory.of("id", "namespace", tenant);
+        var runContext = runContextFactory.of();
         var command  = ScriptService.replaceInternalStorage(runContext, null, false);
         assertThat(command).isEqualTo("");
 
         command = ScriptService.replaceInternalStorage(runContext, "my command", false);
         assertThat(command).isEqualTo("my command");
 
-        Path path = createFile(tenant, "file");
+        Path path = Path.of("/tmp/unittest/main/file.txt");
+        if (!path.toFile().exists()) {
+            Files.createFile(path);
+        }
 
         String internalStorageUri = "kestra://some/file.txt";
         File localFile = null;
@@ -69,10 +70,12 @@ class ScriptServiceTest {
 
     @Test
     void replaceInternalStorageUnicode() throws IOException {
-        String tenant = IdUtils.create();
-        var runContext = runContextFactory.of("id", "namespace", tenant);
+        var runContext = runContextFactory.of();
 
-        Path path = createFile(tenant, "file-龍");
+        Path path = Path.of("/tmp/unittest/main/file-龍.txt");
+        if (!path.toFile().exists()) {
+            Files.createFile(path);
+        }
 
         String internalStorageUri = "kestra://some/file-龍.txt";
         File localFile = null;
@@ -92,10 +95,12 @@ class ScriptServiceTest {
 
     @Test
     void uploadInputFiles() throws IOException {
-        String tenant = IdUtils.create();
-        var runContext = runContextFactory.of("id", "namespace", tenant);
+        var runContext = runContextFactory.of();
 
-        Path path = createFile(tenant, "file");
+        Path path = Path.of("/tmp/unittest/main/file.txt");
+        if (!path.toFile().exists()) {
+            Files.createFile(path);
+        }
 
         List<File> filesToDelete = new ArrayList<>();
         String internalStorageUri = "kestra://some/file.txt";
@@ -138,11 +143,13 @@ class ScriptServiceTest {
 
     @Test
     void uploadOutputFiles() throws IOException {
-        String tenant = IdUtils.create();
-        var runContext = runContextFactory.of("id", "namespace", tenant);
-        Path path = createFile(tenant, "file");
+        var runContext = runContextFactory.of();
+        Path path = Path.of("/tmp/unittest/main/file.txt");
+        if (!path.toFile().exists()) {
+            Files.createFile(path);
+        }
 
-        var outputFiles = ScriptService.uploadOutputFiles(runContext, Path.of("/tmp/unittest/%s".formatted(tenant)));
+        var outputFiles = ScriptService.uploadOutputFiles(runContext, Path.of("/tmp/unittest/main"));
         assertThat(outputFiles, not(anEmptyMap()));
         assertThat(outputFiles.get("file.txt")).isEqualTo(URI.create("kestra:///file.txt"));
 
@@ -225,13 +232,4 @@ class ScriptServiceTest {
             .build();
         return runContextFactory.of(flow, task, execution, taskRun);
     }
-
-    private static Path createFile(String tenant, String fileName) throws IOException {
-        Path path = Path.of("/tmp/unittest/%s/%s.txt".formatted(tenant, fileName));
-        if (!path.toFile().exists()) {
-            Files.createDirectory(Path.of("/tmp/unittest/%s".formatted(tenant)));
-            Files.createFile(path);
-        }
-        return path;
-    }
 }

core/src/test/java/io/kestra/core/models/triggers/multipleflows/AbstractMultipleConditionStorageTest.java

@@ -3,7 +3,6 @@ package io.kestra.core.models.triggers.multipleflows;
 import com.google.common.collect.ImmutableMap;
 import io.kestra.core.junit.annotations.KestraTest;
 import io.kestra.core.models.property.Property;
-import io.kestra.core.utils.TestsUtils;
 import org.apache.commons.lang3.tuple.Pair;
 import org.junit.jupiter.api.Test;
 import io.kestra.plugin.core.condition.ExecutionFlow;
@@ -34,9 +33,8 @@ public abstract class AbstractMultipleConditionStorageTest {
     @Test
     void allDefault() {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
 
@@ -52,9 +50,8 @@ public abstract class AbstractMultipleConditionStorageTest {
     @Test
     void daily() {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().window(Duration.ofDays(1)).windowAdvance(Duration.ofSeconds(0)).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().window(Duration.ofDays(1)).windowAdvance(Duration.ofSeconds(0)).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
 
@@ -70,9 +67,8 @@ public abstract class AbstractMultipleConditionStorageTest {
     @Test
     void dailyAdvance() {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().window(Duration.ofDays(1)).windowAdvance(Duration.ofHours(4).negated()).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().window(Duration.ofDays(1)).windowAdvance(Duration.ofHours(4).negated()).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
 
@@ -88,9 +84,8 @@ public abstract class AbstractMultipleConditionStorageTest {
     @Test
     void hourly() {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().window(Duration.ofHours(1)).windowAdvance(Duration.ofHours(4).negated()).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().window(Duration.ofHours(1)).windowAdvance(Duration.ofHours(4).negated()).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
 
@@ -107,9 +102,8 @@ public abstract class AbstractMultipleConditionStorageTest {
     @Test
     void minutely() {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().window(Duration.ofMinutes(15)).windowAdvance(Duration.ofMinutes(5).negated()).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().window(Duration.ofMinutes(15)).windowAdvance(Duration.ofMinutes(5).negated()).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
 
@@ -121,9 +115,8 @@ public abstract class AbstractMultipleConditionStorageTest {
     @Test
     void expiration() throws Exception {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().window(Duration.ofSeconds(2)).windowAdvance(Duration.ofMinutes(0).negated()).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().window(Duration.ofSeconds(2)).windowAdvance(Duration.ofMinutes(0).negated()).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
         this.save(multipleConditionStorage, pair.getLeft(), Collections.singletonList(window.with(ImmutableMap.of("a", true))));
@@ -143,9 +136,8 @@ public abstract class AbstractMultipleConditionStorageTest {
     @Test
     void expired() throws Exception {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().window(Duration.ofSeconds(2)).windowAdvance(Duration.ofMinutes(0).negated()).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().window(Duration.ofSeconds(2)).windowAdvance(Duration.ofMinutes(0).negated()).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
         this.save(multipleConditionStorage, pair.getLeft(), Collections.singletonList(window.with(ImmutableMap.of("a", true))));
@@ -154,21 +146,20 @@ public abstract class AbstractMultipleConditionStorageTest {
 
         assertThat(window.getResults().get("a")).isTrue();
 
-        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(tenant);
+        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(null);
         assertThat(expired.size()).isZero();
 
         Thread.sleep(2005);
 
-        expired = multipleConditionStorage.expired(tenant);
+        expired = multipleConditionStorage.expired(null);
         assertThat(expired.size()).isEqualTo(1);
     }
 
     @Test
     void dailyTimeDeadline() throws Exception {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().type(Type.DAILY_TIME_DEADLINE).deadline(LocalTime.now().plusSeconds(2)).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().type(Type.DAILY_TIME_DEADLINE).deadline(LocalTime.now().plusSeconds(2)).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
         this.save(multipleConditionStorage, pair.getLeft(), Collections.singletonList(window.with(ImmutableMap.of("a", true))));
@@ -177,21 +168,20 @@ public abstract class AbstractMultipleConditionStorageTest {
 
         assertThat(window.getResults().get("a")).isTrue();
 
-        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(tenant);
+        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(null);
         assertThat(expired.size()).isZero();
 
         Thread.sleep(2005);
 
-        expired = multipleConditionStorage.expired(tenant);
+        expired = multipleConditionStorage.expired(null);
         assertThat(expired.size()).isEqualTo(1);
     }
 
     @Test
     void dailyTimeDeadline_Expired() throws Exception {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().type(Type.DAILY_TIME_DEADLINE).deadline(LocalTime.now().minusSeconds(1)).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().type(Type.DAILY_TIME_DEADLINE).deadline(LocalTime.now().minusSeconds(1)).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
         this.save(multipleConditionStorage, pair.getLeft(), Collections.singletonList(window.with(ImmutableMap.of("a", true))));
@@ -200,17 +190,16 @@ public abstract class AbstractMultipleConditionStorageTest {
 
         assertThat(window.getResults()).isEmpty();
 
-        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(tenant);
+        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(null);
         assertThat(expired.size()).isEqualTo(1);
     }
 
     @Test
-    void dailyTimeWindow() {
+    void dailyTimeWindow() throws Exception {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
         LocalTime startTime = LocalTime.now().truncatedTo(ChronoUnit.MINUTES);
-        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().type(Type.DAILY_TIME_WINDOW).startTime(startTime).endTime(startTime.plusMinutes(5)).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().type(Type.DAILY_TIME_WINDOW).startTime(startTime).endTime(startTime.plusMinutes(5)).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
         this.save(multipleConditionStorage, pair.getLeft(), Collections.singletonList(window.with(ImmutableMap.of("a", true))));
@@ -219,16 +208,15 @@ public abstract class AbstractMultipleConditionStorageTest {
 
         assertThat(window.getResults().get("a")).isTrue();
 
-        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(tenant);
+        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(null);
         assertThat(expired.size()).isZero();
     }
 
     @Test
     void slidingWindow() throws Exception {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().type(Type.SLIDING_WINDOW).window(Duration.ofHours(1)).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().type(Type.SLIDING_WINDOW).window(Duration.ofHours(1)).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
         this.save(multipleConditionStorage, pair.getLeft(), Collections.singletonList(window.with(ImmutableMap.of("a", true))));
@@ -237,13 +225,13 @@ public abstract class AbstractMultipleConditionStorageTest {
 
         assertThat(window.getResults().get("a")).isTrue();
 
-        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(tenant);
+        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(null);
         assertThat(expired.size()).isZero();
     }
 
-    private static Pair<Flow, MultipleCondition> mockFlow(String tenantId, TimeWindow sla) {
+    private static Pair<Flow, MultipleCondition> mockFlow(TimeWindow sla) {
         var multipleCondition = MultipleCondition.builder()
-            .id("condition-multiple-%s".formatted(tenantId))
+            .id("condition-multiple")
             .conditions(ImmutableMap.of(
                 "flow-a", ExecutionFlow.builder()
                     .flowId(Property.ofValue("flow-a"))
@@ -260,7 +248,6 @@ public abstract class AbstractMultipleConditionStorageTest {
         Flow flow = Flow.builder()
             .namespace(NAMESPACE)
             .id("multiple-flow")
-            .tenantId(tenantId)
             .revision(1)
             .triggers(Collections.singletonList(io.kestra.plugin.core.trigger.Flow.builder()
                 .id("trigger-flow")

core/src/test/java/io/kestra/core/reporter/reports/AbstractFeatureUsageReportTest.java

@@ -13,20 +13,21 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 @KestraTest
 public abstract class AbstractFeatureUsageReportTest {
-
+    
     @Inject
     FeatureUsageReport featureUsageReport;
-
+    
     @Test
     public void shouldGetReport() {
         // When
         Instant now = Instant.now();
         FeatureUsageReport.UsageEvent event = featureUsageReport.report(
-            now,
+            now, 
             Reportable.TimeInterval.of(now.minus(Duration.ofDays(1)).atZone(ZoneId.systemDefault()), now.atZone(ZoneId.systemDefault()))
         );
-
+        
         // Then
         assertThat(event.getExecutions().getDailyExecutionsCount().size()).isGreaterThan(0);
+        assertThat(event.getExecutions().getDailyTaskRunsCount()).isNull();
     }
 }

core/src/test/java/io/kestra/core/reporter/reports/AbstractServiceUsageReportTest.java

@@ -10,6 +10,7 @@ import io.kestra.core.server.ServiceType;
 import io.kestra.core.utils.IdUtils;
 import jakarta.inject.Inject;
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
 import java.time.Duration;
@@ -30,6 +31,7 @@ public abstract class AbstractServiceUsageReportTest {
     ServiceInstanceRepositoryInterface serviceInstanceRepository;
     
     @Test
+    @Disabled
     public void shouldGetReport() {
         // Given
         final LocalDate start = LocalDate.now().withDayOfMonth(1);

core/src/test/java/io/kestra/core/reporter/reports/SystemInformationReportTest.java

@@ -18,10 +18,10 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 @KestraTest
 class SystemInformationReportTest {
-
+    
     @Inject
     private SystemInformationReport systemInformationReport;
-
+    
     @Test
     void shouldGetReport() {
         SystemInformationReport.SystemInformationEvent event = systemInformationReport.report(Instant.now());
@@ -32,34 +32,34 @@ class SystemInformationReportTest {
         assertThat(event.host().getHardware().getLogicalProcessorCount()).isNotNull();
         assertThat(event.host().getJvm().getName()).isNotNull();
         assertThat(event.host().getOs().getFamily()).isNotNull();
-        assertThat(event.configurations().getRepositoryType()).isEqualTo("h2");
-        assertThat(event.configurations().getQueueType()).isEqualTo("h2");
+        assertThat(event.configurations().getRepositoryType()).isEqualTo("memory");
+        assertThat(event.configurations().getQueueType()).isEqualTo("memory");
     }
-
+    
     @MockBean(SettingRepositoryInterface.class)
     @Singleton
     static class TestSettingRepository implements SettingRepositoryInterface {
         public static Object UUID = null;
-
+        
         @Override
         public Optional<Setting> findByKey(String key) {
             return Optional.empty();
         }
-
+        
         @Override
         public List<Setting> findAll() {
             return new ArrayList<>();
         }
-
+        
         @Override
         public Setting save(Setting setting) throws ConstraintViolationException {
             if (setting.getKey().equals(Setting.INSTANCE_UUID)) {
                 UUID = setting.getValue();
             }
-
+            
             return setting;
         }
-
+        
         @Override
         public Setting delete(Setting setting) {
             return setting;

core/src/test/java/io/kestra/core/repositories/AbstractExecutionRepositoryTest.java

@@ -25,7 +25,6 @@ import io.kestra.core.models.tasks.ResolvedTask;
 import io.kestra.core.repositories.ExecutionRepositoryInterface.ChildFilter;
 import io.kestra.core.utils.IdUtils;
 import io.kestra.core.utils.NamespaceUtils;
-import io.kestra.core.utils.TestsUtils;
 import io.kestra.plugin.core.dashboard.data.Executions;
 import io.kestra.plugin.core.debug.Return;
 import io.micronaut.data.model.Pageable;
@@ -49,6 +48,7 @@ import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import static io.kestra.core.models.flows.FlowScope.USER;
+import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.Mockito.doReturn;
@@ -62,17 +62,17 @@ public abstract class AbstractExecutionRepositoryTest {
     @Inject
     protected ExecutionRepositoryInterface executionRepository;
 
-    public static Execution.ExecutionBuilder builder(String tenantId, State.Type state, String flowId) {
-        return builder(tenantId, state, flowId, NAMESPACE);
+    public static Execution.ExecutionBuilder builder(State.Type state, String flowId) {
+        return builder(state, flowId, NAMESPACE);
     }
 
-    public static Execution.ExecutionBuilder builder(String tenantId, State.Type state, String flowId, String namespace) {
+    public static Execution.ExecutionBuilder builder(State.Type state, String flowId, String namespace) {
         State finalState = randomDuration(state);
 
         Execution.ExecutionBuilder execution = Execution.builder()
             .id(FriendlyId.createFriendlyId())
             .namespace(namespace)
-            .tenantId(tenantId)
+            .tenantId(MAIN_TENANT)
             .flowId(flowId == null ? FLOW : flowId)
             .flowRevision(1)
             .state(finalState);
@@ -126,11 +126,11 @@ public abstract class AbstractExecutionRepositoryTest {
         return finalState;
     }
 
-    protected void inject(String tenantId) {
-        inject(tenantId, null);
+    protected void inject() {
+        inject(null);
     }
 
-    protected void inject(String tenantId, String executionTriggerId) {
+    protected void inject(String executionTriggerId) {
         ExecutionTrigger executionTrigger = null;
 
         if (executionTriggerId != null) {
@@ -139,7 +139,7 @@ public abstract class AbstractExecutionRepositoryTest {
                 .build();
         }
 
-        executionRepository.save(builder(tenantId, State.Type.RUNNING, null)
+        executionRepository.save(builder(State.Type.RUNNING, null)
             .labels(List.of(
                 new Label("key", "value"),
                 new Label("key2", "value2")
@@ -149,7 +149,6 @@ public abstract class AbstractExecutionRepositoryTest {
         );
         for (int i = 1; i < 28; i++) {
             executionRepository.save(builder(
-                tenantId,
                 i < 5 ? State.Type.RUNNING : (i < 8 ? State.Type.FAILED : State.Type.SUCCESS),
                 i < 15 ? null : "second"
             ).trigger(executionTrigger).build());
@@ -157,7 +156,6 @@ public abstract class AbstractExecutionRepositoryTest {
 
         // add a test execution, this should be ignored in search & statistics
         executionRepository.save(builder(
-            tenantId,
             State.Type.SUCCESS,
             null
         )
@@ -169,10 +167,9 @@ public abstract class AbstractExecutionRepositoryTest {
     @ParameterizedTest
     @MethodSource("filterCombinations")
     void should_find_all(QueryFilter filter, int expectedSize){
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        inject(tenant, "executionTriggerId");
+        inject("executionTriggerId");
 
-        ArrayListTotal<Execution> entries = executionRepository.find(Pageable.UNPAGED, tenant, List.of(filter));
+        ArrayListTotal<Execution> entries = executionRepository.find(Pageable.UNPAGED, MAIN_TENANT, List.of(filter));
 
         assertThat(entries).hasSize(expectedSize);
     }
@@ -195,8 +192,7 @@ public abstract class AbstractExecutionRepositoryTest {
     @ParameterizedTest
     @MethodSource("errorFilterCombinations")
     void should_fail_to_find_all(QueryFilter filter){
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        assertThrows(InvalidQueryFiltersException.class, () -> executionRepository.find(Pageable.UNPAGED, tenant, List.of(filter)));
+        assertThrows(InvalidQueryFiltersException.class, () -> executionRepository.find(Pageable.UNPAGED, MAIN_TENANT, List.of(filter)));
     }
 
     static Stream<QueryFilter> errorFilterCombinations() {
@@ -212,10 +208,9 @@ public abstract class AbstractExecutionRepositoryTest {
 
     @Test
     protected void find() {
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        inject(tenant);
+        inject();
 
-        ArrayListTotal<Execution> executions = executionRepository.find(Pageable.from(1, 10),  tenant, null);
+        ArrayListTotal<Execution> executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, null);
         assertThat(executions.getTotal()).isEqualTo(28L);
         assertThat(executions.size()).isEqualTo(10);
 
@@ -224,7 +219,7 @@ public abstract class AbstractExecutionRepositoryTest {
             .operation(QueryFilter.Op.EQUALS)
             .value( List.of(State.Type.RUNNING, State.Type.FAILED))
             .build());
-        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
         assertThat(executions.getTotal()).isEqualTo(8L);
 
         filters = List.of(QueryFilter.builder()
@@ -232,7 +227,7 @@ public abstract class AbstractExecutionRepositoryTest {
             .operation(QueryFilter.Op.EQUALS)
             .value(Map.of("key", "value"))
             .build());
-        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
         assertThat(executions.getTotal()).isEqualTo(1L);
 
         filters = List.of(QueryFilter.builder()
@@ -240,7 +235,7 @@ public abstract class AbstractExecutionRepositoryTest {
             .operation(QueryFilter.Op.EQUALS)
             .value(Map.of("key", "value2"))
             .build());
-        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
         assertThat(executions.getTotal()).isEqualTo(0L);
 
         filters = List.of(QueryFilter.builder()
@@ -249,7 +244,7 @@ public abstract class AbstractExecutionRepositoryTest {
             .value(Map.of("key", "value", "keyTest", "valueTest"))
             .build()
         );
-        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
         assertThat(executions.getTotal()).isEqualTo(0L);
 
         filters = List.of(QueryFilter.builder()
@@ -257,7 +252,7 @@ public abstract class AbstractExecutionRepositoryTest {
             .operation(QueryFilter.Op.EQUALS)
             .value("second")
             .build());
-        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
         assertThat(executions.getTotal()).isEqualTo(13L);
 
         filters = List.of(QueryFilter.builder()
@@ -271,7 +266,7 @@ public abstract class AbstractExecutionRepositoryTest {
                 .value(NAMESPACE)
                 .build()
         );
-        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
         assertThat(executions.getTotal()).isEqualTo(13L);
 
         filters = List.of(QueryFilter.builder()
@@ -279,7 +274,7 @@ public abstract class AbstractExecutionRepositoryTest {
             .operation(QueryFilter.Op.STARTS_WITH)
             .value("io.kestra")
             .build());
-        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
         assertThat(executions.getTotal()).isEqualTo(28L);
     }
 
@@ -287,16 +282,15 @@ public abstract class AbstractExecutionRepositoryTest {
     protected void findTriggerExecutionId() {
         String executionTriggerId = IdUtils.create();
 
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        inject(tenant, executionTriggerId);
-        inject(tenant);
+        inject(executionTriggerId);
+        inject();
 
         var filters = List.of(QueryFilter.builder()
             .field(QueryFilter.Field.TRIGGER_EXECUTION_ID)
             .operation(QueryFilter.Op.EQUALS)
             .value(executionTriggerId)
             .build());
-        ArrayListTotal<Execution> executions = executionRepository.find(Pageable.from(1, 10), tenant, filters);
+        ArrayListTotal<Execution> executions = executionRepository.find(Pageable.from(1, 10), MAIN_TENANT, filters);
         assertThat(executions.getTotal()).isEqualTo(28L);
         assertThat(executions.size()).isEqualTo(10);
         assertThat(executions.getFirst().getTrigger().getVariables().get("executionId")).isEqualTo(executionTriggerId);
@@ -306,7 +300,7 @@ public abstract class AbstractExecutionRepositoryTest {
             .value(ExecutionRepositoryInterface.ChildFilter.CHILD)
             .build());
 
-        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
         assertThat(executions.getTotal()).isEqualTo(28L);
         assertThat(executions.size()).isEqualTo(10);
         assertThat(executions.getFirst().getTrigger().getVariables().get("executionId")).isEqualTo(executionTriggerId);
@@ -317,21 +311,20 @@ public abstract class AbstractExecutionRepositoryTest {
             .value(ExecutionRepositoryInterface.ChildFilter.MAIN)
             .build());
 
-        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters );
+        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters );
         assertThat(executions.getTotal()).isEqualTo(28L);
         assertThat(executions.size()).isEqualTo(10);
         assertThat(executions.getFirst().getTrigger()).isNull();
 
-        executions = executionRepository.find(Pageable.from(1, 10),  tenant, null);
+        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, null);
         assertThat(executions.getTotal()).isEqualTo(56L);
     }
 
     @Test
     protected void findWithSort() {
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        inject(tenant);
+        inject();
 
-        ArrayListTotal<Execution> executions = executionRepository.find(Pageable.from(1, 10, Sort.of(Sort.Order.desc("id"))),  tenant, null);
+        ArrayListTotal<Execution> executions = executionRepository.find(Pageable.from(1, 10, Sort.of(Sort.Order.desc("id"))),  MAIN_TENANT, null);
         assertThat(executions.getTotal()).isEqualTo(28L);
         assertThat(executions.size()).isEqualTo(10);
 
@@ -340,92 +333,114 @@ public abstract class AbstractExecutionRepositoryTest {
             .operation(QueryFilter.Op.EQUALS)
             .value(List.of(State.Type.RUNNING, State.Type.FAILED))
             .build());
-        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
         assertThat(executions.getTotal()).isEqualTo(8L);
     }
 
     @Test
-    protected void findById() {
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        var execution1 = ExecutionFixture.EXECUTION_1(tenant);
-        executionRepository.save(execution1);
+    protected void findTaskRun() {
+        inject();
 
-        Optional<Execution> full = executionRepository.findById(tenant, execution1.getId());
+        ArrayListTotal<TaskRun> taskRuns = executionRepository.findTaskRun(Pageable.from(1, 10), MAIN_TENANT, null);
+        assertThat(taskRuns.getTotal()).isEqualTo(74L);
+        assertThat(taskRuns.size()).isEqualTo(10);
+
+        var filters = List.of(QueryFilter.builder()
+            .field(QueryFilter.Field.LABELS)
+            .operation(QueryFilter.Op.EQUALS)
+            .value(Map.of("key", "value"))
+            .build());
+
+        taskRuns = executionRepository.findTaskRun(Pageable.from(1, 10), MAIN_TENANT, filters);
+        assertThat(taskRuns.getTotal()).isEqualTo(1L);
+        assertThat(taskRuns.size()).isEqualTo(1);
+    }
+
+
+    @Test
+    protected void findById() {
+        executionRepository.save(ExecutionFixture.EXECUTION_1);
+
+        Optional<Execution> full = executionRepository.findById(MAIN_TENANT, ExecutionFixture.EXECUTION_1.getId());
         assertThat(full.isPresent()).isTrue();
 
         full.ifPresent(current -> {
-            assertThat(full.get().getId()).isEqualTo(execution1.getId());
+            assertThat(full.get().getId()).isEqualTo(ExecutionFixture.EXECUTION_1.getId());
         });
     }
 
     @Test
     protected void shouldFindByIdTestExecution() {
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        var executionTest = ExecutionFixture.EXECUTION_TEST(tenant);
-        executionRepository.save(executionTest);
+        executionRepository.save(ExecutionFixture.EXECUTION_TEST);
 
-        Optional<Execution> full = executionRepository.findById(tenant, executionTest.getId());
+        Optional<Execution> full = executionRepository.findById(null, ExecutionFixture.EXECUTION_TEST.getId());
         assertThat(full.isPresent()).isTrue();
 
         full.ifPresent(current -> {
-            assertThat(full.get().getId()).isEqualTo(executionTest.getId());
+            assertThat(full.get().getId()).isEqualTo(ExecutionFixture.EXECUTION_TEST.getId());
         });
     }
 
     @Test
     protected void purge() {
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        var execution1 = ExecutionFixture.EXECUTION_1(tenant);
-        executionRepository.save(execution1);
+        executionRepository.save(ExecutionFixture.EXECUTION_1);
 
-        Optional<Execution> full = executionRepository.findById(tenant, execution1.getId());
+        Optional<Execution> full = executionRepository.findById(MAIN_TENANT, ExecutionFixture.EXECUTION_1.getId());
         assertThat(full.isPresent()).isTrue();
 
-        executionRepository.purge(execution1);
+        executionRepository.purge(ExecutionFixture.EXECUTION_1);
 
-        full = executionRepository.findById(tenant, execution1.getId());
+        full = executionRepository.findById(null, ExecutionFixture.EXECUTION_1.getId());
         assertThat(full.isPresent()).isFalse();
     }
 
     @Test
-    protected void delete() {
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        var execution1 = ExecutionFixture.EXECUTION_1(tenant);
+    protected void purgeExecutions() {
+        var execution1 = ExecutionFixture.EXECUTION_1;
         executionRepository.save(execution1);
+        var execution2 = ExecutionFixture.EXECUTION_2;
+        executionRepository.save(execution2);
 
-        Optional<Execution> full = executionRepository.findById(tenant, execution1.getId());
+        var results = executionRepository.purge(List.of(execution1, execution2));
+        assertThat(results).isEqualTo(2);
+
+        assertThat(executionRepository.findById(null, execution1.getId())).isEmpty();
+        assertThat(executionRepository.findById(null, execution2.getId())).isEmpty();
+    }
+
+    @Test
+    protected void delete() {
+        executionRepository.save(ExecutionFixture.EXECUTION_1);
+
+        Optional<Execution> full = executionRepository.findById(MAIN_TENANT, ExecutionFixture.EXECUTION_1.getId());
         assertThat(full.isPresent()).isTrue();
 
-        executionRepository.delete(execution1);
+        executionRepository.delete(ExecutionFixture.EXECUTION_1);
 
-        full = executionRepository.findById(tenant, execution1.getId());
+        full = executionRepository.findById(MAIN_TENANT, ExecutionFixture.EXECUTION_1.getId());
         assertThat(full.isPresent()).isFalse();
     }
 
     @Test
     protected void mappingConflict() {
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        executionRepository.save(ExecutionFixture.EXECUTION_2(tenant));
-        executionRepository.save(ExecutionFixture.EXECUTION_1(tenant));
+        executionRepository.save(ExecutionFixture.EXECUTION_2);
+        executionRepository.save(ExecutionFixture.EXECUTION_1);
 
-        ArrayListTotal<Execution> page1 = executionRepository.findByFlowId(tenant, NAMESPACE, FLOW, Pageable.from(1, 10));
+        ArrayListTotal<Execution> page1 = executionRepository.findByFlowId(MAIN_TENANT, NAMESPACE, FLOW, Pageable.from(1, 10));
 
         assertThat(page1.size()).isEqualTo(2);
     }
 
     @Test
     protected void dailyStatistics() throws InterruptedException {
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         for (int i = 0; i < 28; i++) {
             executionRepository.save(builder(
-                tenant,
                 i < 5 ? State.Type.RUNNING : (i < 8 ? State.Type.FAILED : State.Type.SUCCESS),
                 i < 15 ? null : "second"
             ).build());
         }
 
         executionRepository.save(builder(
-            tenant,
             State.Type.SUCCESS,
             "second"
         ).namespace(NamespaceUtils.SYSTEM_FLOWS_DEFAULT_NAMESPACE).build());
@@ -435,14 +450,15 @@ public abstract class AbstractExecutionRepositoryTest {
 
         List<DailyExecutionStatistics> result = executionRepository.dailyStatistics(
             null,
-            tenant,
+            MAIN_TENANT,
             null,
             null,
             null,
             ZonedDateTime.now().minusDays(10),
             ZonedDateTime.now(),
             null,
-            null);
+            null,
+            false);
 
         assertThat(result.size()).isEqualTo(11);
         assertThat(result.get(10).getExecutionCounts().size()).isEqualTo(11);
@@ -454,52 +470,131 @@ public abstract class AbstractExecutionRepositoryTest {
 
         result = executionRepository.dailyStatistics(
             null,
-            tenant,
+            MAIN_TENANT,
             List.of(FlowScope.USER, FlowScope.SYSTEM),
             null,
             null,
             ZonedDateTime.now().minusDays(10),
             ZonedDateTime.now(),
             null,
-            null);
+            null,
+            false);
 
         assertThat(result.size()).isEqualTo(11);
         assertThat(result.get(10).getExecutionCounts().get(State.Type.SUCCESS)).isEqualTo(21L);
 
         result = executionRepository.dailyStatistics(
             null,
-            tenant,
+            MAIN_TENANT,
             List.of(FlowScope.USER),
             null,
             null,
             ZonedDateTime.now().minusDays(10),
             ZonedDateTime.now(),
             null,
-            null);
+            null,
+            false);
         assertThat(result.size()).isEqualTo(11);
         assertThat(result.get(10).getExecutionCounts().get(State.Type.SUCCESS)).isEqualTo(20L);
 
         result = executionRepository.dailyStatistics(
             null,
-            tenant,
+            MAIN_TENANT,
             List.of(FlowScope.SYSTEM),
             null,
             null,
             ZonedDateTime.now().minusDays(10),
             ZonedDateTime.now(),
             null,
-            null);
+            null,
+            false);
         assertThat(result.size()).isEqualTo(11);
         assertThat(result.get(10).getExecutionCounts().get(State.Type.SUCCESS)).isEqualTo(1L);
     }
 
+    @Test
+    protected void taskRunsDailyStatistics() {
+        for (int i = 0; i < 28; i++) {
+            executionRepository.save(builder(
+                i < 5 ? State.Type.RUNNING : (i < 8 ? State.Type.FAILED : State.Type.SUCCESS),
+                i < 15 ? null : "second"
+            ).build());
+        }
+
+        executionRepository.save(builder(
+            State.Type.SUCCESS,
+            "second"
+        ).namespace(NamespaceUtils.SYSTEM_FLOWS_DEFAULT_NAMESPACE).build());
+
+        List<DailyExecutionStatistics> result = executionRepository.dailyStatistics(
+            null,
+            MAIN_TENANT,
+            null,
+            null,
+            null,
+            ZonedDateTime.now().minusDays(10),
+            ZonedDateTime.now(),
+            null,
+            null,
+            true);
+
+        assertThat(result.size()).isEqualTo(11);
+        assertThat(result.get(10).getExecutionCounts().size()).isEqualTo(11);
+        assertThat(result.get(10).getDuration().getAvg().toMillis()).isGreaterThan(0L);
+
+        assertThat(result.get(10).getExecutionCounts().get(State.Type.FAILED)).isEqualTo(3L * 2);
+        assertThat(result.get(10).getExecutionCounts().get(State.Type.RUNNING)).isEqualTo(5L * 2);
+        assertThat(result.get(10).getExecutionCounts().get(State.Type.SUCCESS)).isEqualTo(57L);
+
+        result = executionRepository.dailyStatistics(
+            null,
+            MAIN_TENANT,
+            List.of(FlowScope.USER, FlowScope.SYSTEM),
+            null,
+            null,
+            ZonedDateTime.now().minusDays(10),
+            ZonedDateTime.now(),
+            null,
+            null,
+            true);
+
+        assertThat(result.size()).isEqualTo(11);
+        assertThat(result.get(10).getExecutionCounts().get(State.Type.SUCCESS)).isEqualTo(57L);
+
+        result = executionRepository.dailyStatistics(
+            null,
+            MAIN_TENANT,
+            List.of(FlowScope.USER),
+            null,
+            null,
+            ZonedDateTime.now().minusDays(10),
+            ZonedDateTime.now(),
+            null,
+            null,
+            true);
+        assertThat(result.size()).isEqualTo(11);
+        assertThat(result.get(10).getExecutionCounts().get(State.Type.SUCCESS)).isEqualTo(55L);
+
+        result = executionRepository.dailyStatistics(
+            null,
+            MAIN_TENANT,
+            List.of(FlowScope.SYSTEM),
+            null,
+            null,
+            ZonedDateTime.now().minusDays(10),
+            ZonedDateTime.now(),
+            null,
+            null,
+            true);
+        assertThat(result.size()).isEqualTo(11);
+        assertThat(result.get(10).getExecutionCounts().get(State.Type.SUCCESS)).isEqualTo(2L);
+    }
+
     @SuppressWarnings("OptionalGetWithoutIsPresent")
     @Test
     protected void executionsCount() throws InterruptedException {
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         for (int i = 0; i < 14; i++) {
             executionRepository.save(builder(
-                tenant,
                 State.Type.SUCCESS,
                 i < 2 ? "first" : (i < 5 ? "second" : "third")
             ).build());
@@ -509,7 +604,7 @@ public abstract class AbstractExecutionRepositoryTest {
         Thread.sleep(500);
 
         List<ExecutionCount> result = executionRepository.executionCounts(
-            tenant,
+            MAIN_TENANT,
             List.of(
                 new Flow(NAMESPACE, "first"),
                 new Flow(NAMESPACE, "second"),
@@ -528,7 +623,7 @@ public abstract class AbstractExecutionRepositoryTest {
         assertThat(result.stream().filter(executionCount -> executionCount.getFlowId().equals("missing")).findFirst().get().getCount()).isEqualTo(0L);
 
         result = executionRepository.executionCounts(
-            tenant,
+            MAIN_TENANT,
             List.of(
                 new Flow(NAMESPACE, "first"),
                 new Flow(NAMESPACE, "second"),
@@ -545,7 +640,7 @@ public abstract class AbstractExecutionRepositoryTest {
         assertThat(result.stream().filter(executionCount -> executionCount.getFlowId().equals("third")).findFirst().get().getCount()).isEqualTo(9L);
 
         result = executionRepository.executionCounts(
-            tenant,
+            MAIN_TENANT,
             null,
             null,
             null,
@@ -558,15 +653,14 @@ public abstract class AbstractExecutionRepositoryTest {
 
     @Test
     protected void update() {
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        Execution execution = ExecutionFixture.EXECUTION_1(tenant);
-        executionRepository.save(execution);
+        Execution execution = ExecutionFixture.EXECUTION_1;
+        executionRepository.save(ExecutionFixture.EXECUTION_1);
 
         Label label = new Label("key", "value");
         Execution updated = execution.toBuilder().labels(List.of(label)).build();
         executionRepository.update(updated);
 
-        Optional<Execution> validation = executionRepository.findById(tenant, updated.getId());
+        Optional<Execution> validation = executionRepository.findById(MAIN_TENANT, updated.getId());
         assertThat(validation.isPresent()).isTrue();
         assertThat(validation.get().getLabels().size()).isEqualTo(1);
         assertThat(validation.get().getLabels().getFirst()).isEqualTo(label);
@@ -574,14 +668,13 @@ public abstract class AbstractExecutionRepositoryTest {
 
     @Test
     void shouldFindLatestExecutionGivenState() {
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        Execution earliest = buildWithCreatedDate(tenant, Instant.now().minus(Duration.ofMinutes(10)));
-        Execution latest = buildWithCreatedDate(tenant, Instant.now().minus(Duration.ofMinutes(5)));
+        Execution earliest = buildWithCreatedDate(Instant.now().minus(Duration.ofMinutes(10)));
+        Execution latest = buildWithCreatedDate(Instant.now().minus(Duration.ofMinutes(5)));
 
         executionRepository.save(earliest);
         executionRepository.save(latest);
 
-        Optional<Execution> result = executionRepository.findLatestForStates(tenant, "io.kestra.unittest", "full", List.of(State.Type.CREATED));
+        Optional<Execution> result = executionRepository.findLatestForStates(MAIN_TENANT, "io.kestra.unittest", "full", List.of(State.Type.CREATED));
         assertThat(result.isPresent()).isTrue();
         assertThat(result.get().getId()).isEqualTo(latest.getId());
     }
@@ -621,11 +714,11 @@ public abstract class AbstractExecutionRepositoryTest {
         assertThat(data.get(0).get("date")).isEqualTo(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSXXX").format(ZonedDateTime.ofInstant(startDate, ZoneId.systemDefault()).withSecond(0).withNano(0)));
     }
 
-    private static Execution buildWithCreatedDate(String tenant, Instant instant) {
+    private static Execution buildWithCreatedDate(Instant instant) {
         return Execution.builder()
             .id(IdUtils.create())
             .namespace("io.kestra.unittest")
-            .tenantId(tenant)
+            .tenantId(MAIN_TENANT)
             .flowId("full")
             .flowRevision(1)
             .state(new State(State.Type.CREATED, List.of(new State.History(State.Type.CREATED, instant))))
@@ -636,24 +729,22 @@ public abstract class AbstractExecutionRepositoryTest {
 
     @Test
     protected void findAllAsync() {
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-inject(tenant);
+        inject();
 
-        List<Execution> executions = executionRepository.findAllAsync(tenant).collectList().block();
+        List<Execution> executions = executionRepository.findAllAsync(MAIN_TENANT).collectList().block();
         assertThat(executions).hasSize(29); // used by the backup so it contains TEST executions
     }
 
     @Test
     protected void shouldFindByLabel() {
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-inject(tenant);
+        inject();
 
         List<QueryFilter> filters = List.of(QueryFilter.builder()
             .field(QueryFilter.Field.LABELS)
             .operation(QueryFilter.Op.EQUALS)
             .value(Map.of("key", "value"))
             .build());
-        List<Execution> executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
+        List<Execution> executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
         assertThat(executions.size()).isEqualTo(1L);
 
         // Filtering by two pairs of labels, since now its a and behavior, it should not return anything
@@ -662,16 +753,15 @@ inject(tenant);
             .operation(QueryFilter.Op.EQUALS)
             .value(Map.of("key", "value", "keyother", "valueother"))
             .build());
-        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
         assertThat(executions.size()).isEqualTo(0L);
     }
 
     @Test
     protected void shouldReturnLastExecutionsWhenInputsAreNull() {
-        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        inject(tenant);
+        inject();
 
-        List<Execution> lastExecutions = executionRepository.lastExecutions(tenant, null);
+        List<Execution> lastExecutions = executionRepository.lastExecutions(MAIN_TENANT, null);
 
         assertThat(lastExecutions).isNotEmpty();
         Set<String> flowIds = lastExecutions.stream().map(Execution::getFlowId).collect(Collectors.toSet());

core/src/test/java/io/kestra/core/repositories/AbstractExecutionServiceTest.java

@@ -114,7 +114,8 @@ public abstract class AbstractExecutionServiceTest {
             flow.getId(),
             null,
             ZonedDateTime.now(),
-            null
+            null,
+            100
         );
 
         assertThat(purge.getExecutionsCount()).isEqualTo(1);
@@ -132,7 +133,8 @@ public abstract class AbstractExecutionServiceTest {
             flow.getId(),
             null,
             ZonedDateTime.now(),
-            null
+            null,
+            100
         );
 
         assertThat(purge.getExecutionsCount()).isZero();

core/src/test/java/io/kestra/core/repositories/AbstractFlowRepositoryTest.java

@@ -1,6 +1,7 @@
 package io.kestra.core.repositories;
 
 import com.google.common.collect.ImmutableMap;
+import io.kestra.core.Helpers;
 import io.kestra.core.events.CrudEvent;
 import io.kestra.core.events.CrudEventType;
 import io.kestra.core.exceptions.InvalidQueryFiltersException;
@@ -9,6 +10,7 @@ import io.kestra.core.models.Label;
 import io.kestra.core.models.QueryFilter;
 import io.kestra.core.models.QueryFilter.Field;
 import io.kestra.core.models.QueryFilter.Op;
+import io.kestra.core.models.SearchResult;
 import io.kestra.core.models.conditions.ConditionContext;
 import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.executions.ExecutionTrigger;
@@ -18,6 +20,7 @@ import io.kestra.core.models.property.Property;
 import io.kestra.core.models.triggers.AbstractTrigger;
 import io.kestra.core.models.triggers.PollingTriggerInterface;
 import io.kestra.core.models.triggers.TriggerContext;
+import io.kestra.core.queues.QueueException;
 import io.kestra.core.repositories.ExecutionRepositoryInterface.ChildFilter;
 import io.kestra.core.services.FlowService;
 import io.kestra.core.utils.Await;
@@ -26,19 +29,22 @@ import io.kestra.core.utils.TestsUtils;
 import io.kestra.plugin.core.debug.Return;
 import io.micronaut.context.event.ApplicationEventListener;
 import io.micronaut.data.model.Pageable;
+import io.micronaut.data.model.Sort;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
 import jakarta.validation.ConstraintViolationException;
-import java.util.concurrent.CopyOnWriteArrayList;
 import lombok.*;
 import lombok.experimental.SuperBuilder;
 import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 import org.slf4j.event.Level;
 
+import java.io.IOException;
+import java.net.URISyntaxException;
 import java.time.Duration;
 import java.time.ZonedDateTime;
 import java.util.*;
@@ -46,12 +52,16 @@ import java.util.concurrent.TimeoutException;
 import java.util.stream.Stream;
 
 import static io.kestra.core.models.flows.FlowScope.SYSTEM;
+import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static io.kestra.core.utils.NamespaceUtils.SYSTEM_FLOWS_DEFAULT_NAMESPACE;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+// If some counts are wrong in this test it means that one of the tests is not properly deleting what it created
 @KestraTest
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
 public abstract class AbstractFlowRepositoryTest {
+    public static final String TEST_TENANT_ID = "tenant";
     public static final String TEST_NAMESPACE = "io.kestra.unittest";
     public static final String TEST_FLOW_ID = "test";
     @Inject
@@ -60,18 +70,21 @@ public abstract class AbstractFlowRepositoryTest {
     @Inject
     protected ExecutionRepositoryInterface executionRepository;
 
-    @BeforeAll
-    protected static void init() {
+    @Inject
+    private LocalFlowRepositoryLoader repositoryLoader;
+
+    @BeforeEach
+    protected void init() throws IOException, URISyntaxException {
+        TestsUtils.loads(MAIN_TENANT, repositoryLoader);
         FlowListener.reset();
     }
 
-    private static FlowWithSource.FlowWithSourceBuilder<?, ?> builder(String tenantId) {
-        return builder(tenantId, IdUtils.create(), TEST_FLOW_ID);
+    private static FlowWithSource.FlowWithSourceBuilder<?, ?> builder() {
+        return builder(IdUtils.create(), TEST_FLOW_ID);
     }
 
-    private static FlowWithSource.FlowWithSourceBuilder<?, ?> builder(String tenantId, String flowId, String taskId) {
+    private static FlowWithSource.FlowWithSourceBuilder<?, ?> builder(String flowId, String taskId) {
         return FlowWithSource.builder()
-            .tenantId(tenantId)
             .id(flowId)
             .namespace(TEST_NAMESPACE)
             .tasks(Collections.singletonList(Return.builder().id(taskId).type(Return.class.getName()).format(Property.ofValue(TEST_FLOW_ID)).build()));
@@ -80,16 +93,16 @@ public abstract class AbstractFlowRepositoryTest {
     @ParameterizedTest
     @MethodSource("filterCombinations")
     void should_find_all(QueryFilter filter){
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+
         FlowWithSource flow = FlowWithSource.builder()
             .id("filterFlowId")
             .namespace(SYSTEM_FLOWS_DEFAULT_NAMESPACE)
-            .tenantId(tenant)
+            .tenantId(MAIN_TENANT)
             .labels(Label.from(Map.of("key", "value")))
             .build();
         flow = flowRepository.create(GenericFlow.of(flow));
         try {
-            ArrayListTotal<Flow> entries = flowRepository.find(Pageable.UNPAGED, tenant, List.of(filter));
+            ArrayListTotal<Flow> entries = flowRepository.find(Pageable.UNPAGED, MAIN_TENANT, List.of(filter));
 
             assertThat(entries).hasSize(1);
         } finally {
@@ -100,16 +113,16 @@ public abstract class AbstractFlowRepositoryTest {
     @ParameterizedTest
     @MethodSource("filterCombinations")
     void should_find_all_with_source(QueryFilter filter){
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+
         FlowWithSource flow = FlowWithSource.builder()
             .id("filterFlowId")
             .namespace(SYSTEM_FLOWS_DEFAULT_NAMESPACE)
-            .tenantId(tenant)
+            .tenantId(MAIN_TENANT)
             .labels(Label.from(Map.of("key", "value")))
             .build();
         flow = flowRepository.create(GenericFlow.of(flow));
         try {
-            ArrayListTotal<FlowWithSource> entries = flowRepository.findWithSource(Pageable.UNPAGED, tenant, List.of(filter));
+            ArrayListTotal<FlowWithSource> entries = flowRepository.findWithSource(Pageable.UNPAGED, MAIN_TENANT, List.of(filter));
 
             assertThat(entries).hasSize(1);
         } finally {
@@ -131,7 +144,7 @@ public abstract class AbstractFlowRepositoryTest {
     void should_fail_to_find_all(QueryFilter filter){
         assertThrows(
             InvalidQueryFiltersException.class,
-            () -> flowRepository.find(Pageable.UNPAGED, TestsUtils.randomTenant(this.getClass().getSimpleName()), List.of(filter)));
+            () -> flowRepository.find(Pageable.UNPAGED, MAIN_TENANT, List.of(filter)));
 
     }
 
@@ -140,7 +153,7 @@ public abstract class AbstractFlowRepositoryTest {
     void should_fail_to_find_all_with_source(QueryFilter filter){
         assertThrows(
             InvalidQueryFiltersException.class,
-            () -> flowRepository.findWithSource(Pageable.UNPAGED, TestsUtils.randomTenant(this.getClass().getSimpleName()), List.of(filter)));
+            () -> flowRepository.findWithSource(Pageable.UNPAGED, MAIN_TENANT, List.of(filter)));
 
     }
 
@@ -163,17 +176,17 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     void findById() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        FlowWithSource flow = builder(tenant)
+        FlowWithSource flow = builder()
+            .tenantId(MAIN_TENANT)
             .revision(3)
             .build();
         flow = flowRepository.create(GenericFlow.of(flow));
         try {
-            Optional<Flow> full = flowRepository.findById(tenant, flow.getNamespace(), flow.getId());
+            Optional<Flow> full = flowRepository.findById(MAIN_TENANT, flow.getNamespace(), flow.getId());
             assertThat(full.isPresent()).isTrue();
             assertThat(full.get().getRevision()).isEqualTo(1);
 
-            full = flowRepository.findById(tenant, flow.getNamespace(), flow.getId(), Optional.empty());
+            full = flowRepository.findById(MAIN_TENANT, flow.getNamespace(), flow.getId(), Optional.empty());
             assertThat(full.isPresent()).isTrue();
         } finally {
             deleteFlow(flow);
@@ -182,18 +195,17 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     void findByIdWithoutAcl() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        FlowWithSource flow = builder(tenant)
-            .tenantId(tenant)
+        FlowWithSource flow = builder()
+            .tenantId(MAIN_TENANT)
             .revision(3)
             .build();
         flow = flowRepository.create(GenericFlow.of(flow));
         try {
-            Optional<Flow> full = flowRepository.findByIdWithoutAcl(tenant, flow.getNamespace(), flow.getId(), Optional.empty());
+            Optional<Flow> full = flowRepository.findByIdWithoutAcl(MAIN_TENANT, flow.getNamespace(), flow.getId(), Optional.empty());
             assertThat(full.isPresent()).isTrue();
             assertThat(full.get().getRevision()).isEqualTo(1);
 
-            full = flowRepository.findByIdWithoutAcl(tenant, flow.getNamespace(), flow.getId(), Optional.empty());
+            full = flowRepository.findByIdWithoutAcl(MAIN_TENANT, flow.getNamespace(), flow.getId(), Optional.empty());
             assertThat(full.isPresent()).isTrue();
         } finally {
             deleteFlow(flow);
@@ -202,16 +214,15 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     void findByIdWithSource() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        FlowWithSource flow = builder(tenant)
-            .tenantId(tenant)
+        FlowWithSource flow = builder()
+            .tenantId(MAIN_TENANT)
             .revision(3)
             .build();
         String source = "# comment\n" + flow.sourceOrGenerateIfNull();
-        flow = flowRepository.create(GenericFlow.fromYaml(tenant, source));
+        flow = flowRepository.create(GenericFlow.fromYaml(MAIN_TENANT, source));
 
         try {
-            Optional<FlowWithSource> full = flowRepository.findByIdWithSource(tenant, flow.getNamespace(), flow.getId());
+            Optional<FlowWithSource> full = flowRepository.findByIdWithSource(MAIN_TENANT, flow.getNamespace(), flow.getId());
             assertThat(full.isPresent()).isTrue();
 
             full.ifPresent(current -> {
@@ -226,8 +237,7 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     void save() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        FlowWithSource flow = builder(tenant).revision(12).build();
+        FlowWithSource flow = builder().revision(12).build();
         FlowWithSource save = flowRepository.create(GenericFlow.of(flow));
 
         try {
@@ -239,8 +249,7 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     void saveNoRevision() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        FlowWithSource flow = builder(tenant).build();
+        FlowWithSource flow = builder().build();
         FlowWithSource save = flowRepository.create(GenericFlow.of(flow));
 
         try {
@@ -251,17 +260,56 @@ public abstract class AbstractFlowRepositoryTest {
 
     }
 
+    @Test
+    void findAll() {
+        List<Flow> save = flowRepository.findAll(MAIN_TENANT);
+
+        assertThat((long) save.size()).isEqualTo(Helpers.FLOWS_COUNT);
+    }
+
+    @Test
+    void findAllWithSource() {
+        List<FlowWithSource> save = flowRepository.findAllWithSource(MAIN_TENANT);
+
+        assertThat((long) save.size()).isEqualTo(Helpers.FLOWS_COUNT);
+    }
+
+    @Test
+    void findAllForAllTenants() {
+        List<Flow> save = flowRepository.findAllForAllTenants();
+
+        assertThat((long) save.size()).isEqualTo(Helpers.FLOWS_COUNT);
+    }
+
+    @Test
+    void findAllWithSourceForAllTenants() {
+        List<FlowWithSource> save = flowRepository.findAllWithSourceForAllTenants();
+
+        assertThat((long) save.size()).isEqualTo(Helpers.FLOWS_COUNT);
+    }
+
+    @Test
+    void findByNamespacePrefix() {
+        List<Flow> save = flowRepository.findByNamespacePrefix(MAIN_TENANT, "io.kestra.tests");
+        assertThat((long) save.size()).isEqualTo(Helpers.FLOWS_COUNT - 1);
+
+        save = flowRepository.findByNamespace(MAIN_TENANT, "io.kestra.tests2");
+        assertThat((long) save.size()).isEqualTo(1L);
+
+        save = flowRepository.findByNamespace(MAIN_TENANT, "io.kestra.tests.minimal.bis");
+        assertThat((long) save.size()).isEqualTo(1L);
+    }
+
     @Test
     void findByNamespaceWithSource() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        Flow flow = builder(tenant)
+        Flow flow = builder()
             .revision(3)
             .build();
         String flowSource = "# comment\n" + flow.sourceOrGenerateIfNull();
-        flow = flowRepository.create(GenericFlow.fromYaml(tenant, flowSource));
+        flow = flowRepository.create(GenericFlow.fromYaml(MAIN_TENANT, flowSource));
 
         try {
-            List<FlowWithSource> save = flowRepository.findByNamespaceWithSource(tenant, flow.getNamespace());
+            List<FlowWithSource> save = flowRepository.findByNamespaceWithSource(MAIN_TENANT, flow.getNamespace());
             assertThat((long) save.size()).isEqualTo(1L);
 
             assertThat(save.getFirst().getSource()).isEqualTo(FlowService.cleanupSource(flowSource));
@@ -270,15 +318,175 @@ public abstract class AbstractFlowRepositoryTest {
         }
     }
 
+    @Test
+    void findByNamespacePrefixWithSource() {
+        List<FlowWithSource> save = flowRepository.findByNamespacePrefixWithSource(MAIN_TENANT, "io.kestra.tests");
+        assertThat((long) save.size()).isEqualTo(Helpers.FLOWS_COUNT - 1);
+    }
+
+    @Test
+    void find_paginationPartial() {
+        assertThat(flowRepository.find(Pageable.from(1, (int) Helpers.FLOWS_COUNT - 1, Sort.UNSORTED), MAIN_TENANT, null)
+            .size())
+            .describedAs("When paginating at MAX-1, it should return MAX-1")
+            .isEqualTo(Helpers.FLOWS_COUNT - 1);
+
+        assertThat(flowRepository.findWithSource(Pageable.from(1, (int) Helpers.FLOWS_COUNT - 1, Sort.UNSORTED), MAIN_TENANT, null)
+            .size())
+            .describedAs("When paginating at MAX-1, it should return MAX-1")
+            .isEqualTo(Helpers.FLOWS_COUNT - 1);
+    }
+
+    @Test
+    void find_paginationGreaterThanExisting() {
+        assertThat(flowRepository.find(Pageable.from(1, (int) Helpers.FLOWS_COUNT + 1, Sort.UNSORTED), MAIN_TENANT, null)
+            .size())
+            .describedAs("When paginating requesting a larger amount than existing, it should return existing MAX")
+            .isEqualTo(Helpers.FLOWS_COUNT);
+        assertThat(flowRepository.findWithSource(Pageable.from(1, (int) Helpers.FLOWS_COUNT + 1, Sort.UNSORTED), MAIN_TENANT, null)
+            .size())
+            .describedAs("When paginating requesting a larger amount than existing, it should return existing MAX")
+            .isEqualTo(Helpers.FLOWS_COUNT);
+    }
+
+    @Test
+    void find_prefixMatchingAllNamespaces() {
+        assertThat(flowRepository.find(
+            Pageable.UNPAGED,
+            MAIN_TENANT,
+            List.of(
+                QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.STARTS_WITH).value("io.kestra.tests").build()
+            )
+        ).size())
+            .describedAs("When filtering on NAMESPACE START_WITH a pattern that match all, it should return all")
+            .isEqualTo(Helpers.FLOWS_COUNT);
+
+        assertThat(flowRepository.findWithSource(
+            Pageable.UNPAGED,
+            MAIN_TENANT,
+            List.of(
+                QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.STARTS_WITH).value("io.kestra.tests").build()
+            )
+        ).size())
+            .describedAs("When filtering on NAMESPACE START_WITH a pattern that match all, it should return all")
+            .isEqualTo(Helpers.FLOWS_COUNT);
+    }
+
+    @Test
+    void find_aSpecifiedNamespace() {
+        assertThat(flowRepository.find(
+            Pageable.UNPAGED,
+            MAIN_TENANT,
+            List.of(
+                QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.EQUALS).value("io.kestra.tests2").build()
+            )
+        ).size()).isEqualTo(1L);
+
+        assertThat(flowRepository.findWithSource(
+            Pageable.UNPAGED,
+            MAIN_TENANT,
+            List.of(
+                QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.EQUALS).value("io.kestra.tests2").build()
+            )
+        ).size()).isEqualTo(1L);
+    }
+
+    @Test
+    void find_aSpecificSubNamespace() {
+        assertThat(flowRepository.find(
+            Pageable.UNPAGED,
+            MAIN_TENANT,
+            List.of(
+                QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.EQUALS).value("io.kestra.tests.minimal.bis").build()
+            )
+        ).size())
+            .isEqualTo(1L);
+
+        assertThat(flowRepository.findWithSource(
+            Pageable.UNPAGED,
+            MAIN_TENANT,
+            List.of(
+                QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.EQUALS).value("io.kestra.tests.minimal.bis").build()
+            )
+        ).size())
+            .isEqualTo(1L);
+    }
+
+    @Test
+    void find_aSpecificLabel() {
+        assertThat(
+            flowRepository.find(Pageable.UNPAGED, MAIN_TENANT,
+                List.of(
+                    QueryFilter.builder().field(QueryFilter.Field.LABELS).operation(QueryFilter.Op.EQUALS).value(Map.of("country", "FR")).build()
+                )
+            ).size())
+            .isEqualTo(1);
+
+        assertThat(
+            flowRepository.findWithSource(Pageable.UNPAGED, MAIN_TENANT,
+                List.of(
+                    QueryFilter.builder().field(QueryFilter.Field.LABELS).operation(QueryFilter.Op.EQUALS).value(Map.of("country", "FR")).build()
+                )
+            ).size())
+            .isEqualTo(1);
+    }
+
+    @Test
+    void find_aSpecificFlowByNamespaceAndLabel() {
+        assertThat(
+            flowRepository.find(Pageable.UNPAGED, MAIN_TENANT,
+                List.of(
+                    QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.EQUALS).value("io.kestra.tests").build(),
+                    QueryFilter.builder().field(QueryFilter.Field.LABELS).operation(QueryFilter.Op.EQUALS).value(Map.of("key2", "value2")).build()
+                )
+            ).size())
+            .isEqualTo(1);
+
+        assertThat(
+            flowRepository.findWithSource(Pageable.UNPAGED, MAIN_TENANT,
+                List.of(
+                    QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.EQUALS).value("io.kestra.tests").build(),
+                    QueryFilter.builder().field(QueryFilter.Field.LABELS).operation(QueryFilter.Op.EQUALS).value(Map.of("key2", "value2")).build()
+                )
+            ).size())
+            .isEqualTo(1);
+    }
+
+    @Test
+    void find_noResult_forAnUnknownNamespace() {
+        assertThat(
+            flowRepository.find(Pageable.UNPAGED, MAIN_TENANT,
+                List.of(
+                    QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.EQUALS).value("io.kestra.tests").build(),
+                    QueryFilter.builder().field(QueryFilter.Field.LABELS).operation(QueryFilter.Op.EQUALS).value(Map.of("key1", "value2")).build()
+                )
+            ).size())
+            .isEqualTo(0);
+
+        assertThat(
+            flowRepository.findWithSource(Pageable.UNPAGED, MAIN_TENANT,
+                List.of(
+                    QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.EQUALS).value("io.kestra.tests").build(),
+                    QueryFilter.builder().field(QueryFilter.Field.LABELS).operation(QueryFilter.Op.EQUALS).value(Map.of("key1", "value2")).build()
+                )
+            ).size())
+            .isEqualTo(0);
+    }
+
+    @Test
+    protected void findSpecialChars() {
+        ArrayListTotal<SearchResult<Flow>> save = flowRepository.findSourceCode(Pageable.unpaged(), "https://api.chucknorris.io", MAIN_TENANT, null);
+        assertThat((long) save.size()).isEqualTo(2L);
+    }
+
     @Test
     void delete() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        Flow flow = builder(tenant).tenantId(tenant).build();
+        Flow flow = builder().tenantId(MAIN_TENANT).build();
 
         FlowWithSource save = flowRepository.create(GenericFlow.of(flow));
 
         try {
-            assertThat(flowRepository.findById(tenant, save.getNamespace(), save.getId()).isPresent()).isTrue();
+            assertThat(flowRepository.findById(MAIN_TENANT, save.getNamespace(), save.getId()).isPresent()).isTrue();
         } catch (Throwable e) {
             deleteFlow(save);
             throw e;
@@ -286,22 +494,21 @@ public abstract class AbstractFlowRepositoryTest {
 
         Flow delete = flowRepository.delete(save);
 
-        assertThat(flowRepository.findById(tenant, flow.getNamespace(), flow.getId()).isPresent()).isFalse();
-        assertThat(flowRepository.findById(tenant, flow.getNamespace(), flow.getId(), Optional.of(save.getRevision())).isPresent()).isTrue();
+        assertThat(flowRepository.findById(MAIN_TENANT, flow.getNamespace(), flow.getId()).isPresent()).isFalse();
+        assertThat(flowRepository.findById(MAIN_TENANT, flow.getNamespace(), flow.getId(), Optional.of(save.getRevision())).isPresent()).isTrue();
 
-        List<FlowWithSource> revisions = flowRepository.findRevisions(tenant, flow.getNamespace(), flow.getId());
+        List<FlowWithSource> revisions = flowRepository.findRevisions(MAIN_TENANT, flow.getNamespace(), flow.getId());
         assertThat(revisions.getLast().getRevision()).isEqualTo(delete.getRevision());
     }
 
     @Test
     void updateConflict() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         String flowId = IdUtils.create();
 
         Flow flow = Flow.builder()
             .id(flowId)
             .namespace(TEST_NAMESPACE)
-            .tenantId(tenant)
+            .tenantId(MAIN_TENANT)
             .inputs(List.of(StringInput.builder().type(Type.STRING).id("a").build()))
             .tasks(Collections.singletonList(Return.builder().id(TEST_FLOW_ID).type(Return.class.getName()).format(Property.ofValue(TEST_FLOW_ID)).build()))
             .build();
@@ -309,12 +516,12 @@ public abstract class AbstractFlowRepositoryTest {
         Flow save = flowRepository.create(GenericFlow.of(flow));
 
         try {
-            assertThat(flowRepository.findById(tenant, flow.getNamespace(), flow.getId()).isPresent()).isTrue();
+            assertThat(flowRepository.findById(MAIN_TENANT, flow.getNamespace(), flow.getId()).isPresent()).isTrue();
 
             Flow update = Flow.builder()
                 .id(IdUtils.create())
                 .namespace("io.kestra.unittest2")
-                .tenantId(tenant)
+                .tenantId(MAIN_TENANT)
                 .inputs(List.of(StringInput.builder().type(Type.STRING).id("b").build()))
                 .tasks(Collections.singletonList(Return.builder().id(TEST_FLOW_ID).type(Return.class.getName()).format(Property.ofValue(TEST_FLOW_ID)).build()))
                 .build();
@@ -332,14 +539,13 @@ public abstract class AbstractFlowRepositoryTest {
     }
 
     @Test
-    public void removeTrigger() throws TimeoutException {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+    void removeTrigger() throws TimeoutException, QueueException {
         String flowId = IdUtils.create();
 
         Flow flow = Flow.builder()
             .id(flowId)
             .namespace(TEST_NAMESPACE)
-            .tenantId(tenant)
+            .tenantId(MAIN_TENANT)
             .triggers(Collections.singletonList(UnitTest.builder()
                 .id("sleep")
                 .type(UnitTest.class.getName())
@@ -349,12 +555,12 @@ public abstract class AbstractFlowRepositoryTest {
 
         flow = flowRepository.create(GenericFlow.of(flow));
         try {
-            assertThat(flowRepository.findById(tenant, flow.getNamespace(), flow.getId()).isPresent()).isTrue();
+            assertThat(flowRepository.findById(MAIN_TENANT, flow.getNamespace(), flow.getId()).isPresent()).isTrue();
 
             Flow update = Flow.builder()
                 .id(flowId)
                 .namespace(TEST_NAMESPACE)
-                .tenantId(tenant)
+                .tenantId(MAIN_TENANT)
                 .tasks(Collections.singletonList(Return.builder().id(TEST_FLOW_ID).type(Return.class.getName()).format(Property.ofValue(TEST_FLOW_ID)).build()))
                 .build();
             ;
@@ -365,25 +571,21 @@ public abstract class AbstractFlowRepositoryTest {
             deleteFlow(flow);
         }
 
-        Await.until(() -> FlowListener.filterByTenant(tenant)
-            .size() == 3, Duration.ofMillis(100), Duration.ofSeconds(5));
-        assertThat(FlowListener.filterByTenant(tenant).stream()
-            .filter(r -> r.getType() == CrudEventType.CREATE).count()).isEqualTo(1L);
-        assertThat(FlowListener.filterByTenant(tenant).stream()
-            .filter(r -> r.getType() == CrudEventType.UPDATE).count()).isEqualTo(1L);
-        assertThat(FlowListener.filterByTenant(tenant).stream()
-            .filter(r -> r.getType() == CrudEventType.DELETE).count()).isEqualTo(1L);
+        Await.until(() -> FlowListener.getEmits().size() == 3, Duration.ofMillis(100), Duration.ofSeconds(5));
+        assertThat(FlowListener.getEmits().stream().filter(r -> r.getType() == CrudEventType.CREATE).count()).isEqualTo(1L);
+        assertThat(FlowListener.getEmits().stream().filter(r -> r.getType() == CrudEventType.UPDATE).count()).isEqualTo(1L);
+        assertThat(FlowListener.getEmits().stream().filter(r -> r.getType() == CrudEventType.DELETE).count()).isEqualTo(1L);
     }
 
+
     @Test
     void removeTriggerDelete() throws TimeoutException {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         String flowId = IdUtils.create();
 
         Flow flow = Flow.builder()
             .id(flowId)
             .namespace(TEST_NAMESPACE)
-            .tenantId(tenant)
+            .tenantId(MAIN_TENANT)
             .triggers(Collections.singletonList(UnitTest.builder()
                 .id("sleep")
                 .type(UnitTest.class.getName())
@@ -393,39 +595,34 @@ public abstract class AbstractFlowRepositoryTest {
 
         Flow save = flowRepository.create(GenericFlow.of(flow));
         try {
-            assertThat(flowRepository.findById(tenant, flow.getNamespace(), flow.getId()).isPresent()).isTrue();
+            assertThat(flowRepository.findById(MAIN_TENANT, flow.getNamespace(), flow.getId()).isPresent()).isTrue();
         } finally {
             deleteFlow(save);
         }
 
-        Await.until(() -> FlowListener.filterByTenant(tenant)
-            .size() == 2, Duration.ofMillis(100), Duration.ofSeconds(5));
-        assertThat(FlowListener.filterByTenant(tenant).stream()
-            .filter(r -> r.getType() == CrudEventType.CREATE).count()).isEqualTo(1L);
-        assertThat(FlowListener.filterByTenant(tenant).stream()
-            .filter(r -> r.getType() == CrudEventType.DELETE).count()).isEqualTo(1L);
+        Await.until(() -> FlowListener.getEmits().size() == 2, Duration.ofMillis(100), Duration.ofSeconds(5));
+        assertThat(FlowListener.getEmits().stream().filter(r -> r.getType() == CrudEventType.CREATE).count()).isEqualTo(1L);
+        assertThat(FlowListener.getEmits().stream().filter(r -> r.getType() == CrudEventType.DELETE).count()).isEqualTo(1L);
     }
 
-
     @Test
     protected void shouldReturnNullRevisionForNonExistingFlow() {
-        assertThat(flowRepository.lastRevision(TestsUtils.randomTenant(this.getClass().getSimpleName()), TEST_NAMESPACE, IdUtils.create())).isNull();
+        assertThat(flowRepository.lastRevision(TEST_TENANT_ID, TEST_NAMESPACE, IdUtils.create())).isNull();
     }
 
     @Test
     protected void shouldReturnLastRevisionOnCreate() {
         // Given
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         final List<Flow> toDelete = new ArrayList<>();
         final String flowId = IdUtils.create();
         try {
             // When
-            toDelete.add(flowRepository.create(createTestingLogFlow(tenant, flowId, "???")));
-            Integer result = flowRepository.lastRevision(tenant, TEST_NAMESPACE, flowId);
+            toDelete.add(flowRepository.create(createTestingLogFlow(flowId, "???")));
+            Integer result = flowRepository.lastRevision(TEST_TENANT_ID, TEST_NAMESPACE, flowId);
 
             // Then
             assertThat(result).isEqualTo(1);
-            assertThat(flowRepository.lastRevision(tenant, TEST_NAMESPACE, flowId)).isEqualTo(1);
+            assertThat(flowRepository.lastRevision(TEST_TENANT_ID, TEST_NAMESPACE, flowId)).isEqualTo(1);
         } finally {
             toDelete.forEach(this::deleteFlow);
         }
@@ -434,36 +631,34 @@ public abstract class AbstractFlowRepositoryTest {
     @Test
     protected void shouldIncrementRevisionOnDelete() {
         // Given
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         final String flowId = IdUtils.create();
-        FlowWithSource created = flowRepository.create(createTestingLogFlow(tenant, flowId, "first"));
-        assertThat(flowRepository.findRevisions(tenant, TEST_NAMESPACE, flowId).size()).isEqualTo(1);
+        FlowWithSource created = flowRepository.create(createTestingLogFlow(flowId, "first"));
+        assertThat(flowRepository.findRevisions(TEST_TENANT_ID, TEST_NAMESPACE, flowId).size()).isEqualTo(1);
 
         // When
         flowRepository.delete(created);
 
         // Then
-        assertThat(flowRepository.findRevisions(tenant, TEST_NAMESPACE, flowId).size()).isEqualTo(2);
+        assertThat(flowRepository.findRevisions(TEST_TENANT_ID, TEST_NAMESPACE, flowId).size()).isEqualTo(2);
     }
 
     @Test
     protected void shouldIncrementRevisionOnCreateAfterDelete() {
         // Given
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         final List<Flow> toDelete = new ArrayList<>();
         final String flowId = IdUtils.create();
         try {
             // Given
             flowRepository.delete(
-                flowRepository.create(createTestingLogFlow(tenant, flowId, "first"))
+                flowRepository.create(createTestingLogFlow(flowId, "first"))
             );
 
             // When
-            toDelete.add(flowRepository.create(createTestingLogFlow(tenant, flowId, "second")));
+            toDelete.add(flowRepository.create(createTestingLogFlow(flowId, "second")));
 
             // Then
-            assertThat(flowRepository.findRevisions(tenant, TEST_NAMESPACE, flowId).size()).isEqualTo(3);
-            assertThat(flowRepository.lastRevision(tenant, TEST_NAMESPACE, flowId)).isEqualTo(3);
+            assertThat(flowRepository.findRevisions(TEST_TENANT_ID, TEST_NAMESPACE, flowId).size()).isEqualTo(3);
+            assertThat(flowRepository.lastRevision(TEST_TENANT_ID, TEST_NAMESPACE, flowId)).isEqualTo(3);
         } finally {
             toDelete.forEach(this::deleteFlow);
         }
@@ -472,23 +667,22 @@ public abstract class AbstractFlowRepositoryTest {
     @Test
     protected void shouldReturnNullForLastRevisionAfterDelete() {
         // Given
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         final List<Flow> toDelete = new ArrayList<>();
         final String flowId = IdUtils.create();
         try {
             // Given
-            FlowWithSource created = flowRepository.create(createTestingLogFlow(tenant, flowId, "first"));
+            FlowWithSource created = flowRepository.create(createTestingLogFlow(flowId, "first"));
             toDelete.add(created);
 
-            FlowWithSource updated = flowRepository.update(createTestingLogFlow(tenant, flowId, "second"), created);
+            FlowWithSource updated = flowRepository.update(createTestingLogFlow(flowId, "second"), created);
             toDelete.add(updated);
 
             // When
             flowRepository.delete(updated);
 
             // Then
-            assertThat(flowRepository.findById(tenant, TEST_NAMESPACE, flowId, Optional.empty())).isEqualTo(Optional.empty());
-            assertThat(flowRepository.lastRevision(tenant, TEST_NAMESPACE, flowId)).isNull();
+            assertThat(flowRepository.findById(TEST_TENANT_ID, TEST_NAMESPACE, flowId, Optional.empty())).isEqualTo(Optional.empty());
+            assertThat(flowRepository.lastRevision(TEST_TENANT_ID, TEST_NAMESPACE, flowId)).isNull();
         } finally {
             toDelete.forEach(this::deleteFlow);
         }
@@ -497,23 +691,22 @@ public abstract class AbstractFlowRepositoryTest {
     @Test
     protected void shouldFindAllRevisionsAfterDelete() {
         // Given
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         final List<Flow> toDelete = new ArrayList<>();
         final String flowId = IdUtils.create();
         try {
             // Given
-            FlowWithSource created = flowRepository.create(createTestingLogFlow(tenant, flowId, "first"));
+            FlowWithSource created = flowRepository.create(createTestingLogFlow(flowId, "first"));
             toDelete.add(created);
 
-            FlowWithSource updated = flowRepository.update(createTestingLogFlow(tenant, flowId, "second"), created);
+            FlowWithSource updated = flowRepository.update(createTestingLogFlow(flowId, "second"), created);
             toDelete.add(updated);
 
             // When
             flowRepository.delete(updated);
 
             // Then
-            assertThat(flowRepository.findById(tenant, TEST_NAMESPACE, flowId, Optional.empty())).isEqualTo(Optional.empty());
-            assertThat(flowRepository.findRevisions(tenant, TEST_NAMESPACE, flowId).size()).isEqualTo(3);
+            assertThat(flowRepository.findById(TEST_TENANT_ID, TEST_NAMESPACE, flowId, Optional.empty())).isEqualTo(Optional.empty());
+            assertThat(flowRepository.findRevisions(TEST_TENANT_ID, TEST_NAMESPACE, flowId).size()).isEqualTo(3);
         } finally {
             toDelete.forEach(this::deleteFlow);
         }
@@ -521,22 +714,21 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     protected void shouldIncrementRevisionOnUpdateGivenNotEqualSource() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         final List<Flow> toDelete = new ArrayList<>();
         final String flowId = IdUtils.create();
         try {
 
             // Given
-            FlowWithSource created = flowRepository.create(createTestingLogFlow(tenant, flowId, "first"));
+            FlowWithSource created = flowRepository.create(createTestingLogFlow(flowId, "first"));
             toDelete.add(created);
 
             // When
-            FlowWithSource updated = flowRepository.update(createTestingLogFlow(tenant, flowId, "second"), created);
+            FlowWithSource updated = flowRepository.update(createTestingLogFlow(flowId, "second"), created);
             toDelete.add(updated);
 
             // Then
             assertThat(updated.getRevision()).isEqualTo(2);
-            assertThat(flowRepository.lastRevision(tenant, TEST_NAMESPACE, flowId)).isEqualTo(2);
+            assertThat(flowRepository.lastRevision(TEST_TENANT_ID, TEST_NAMESPACE, flowId)).isEqualTo(2);
 
         } finally {
             toDelete.forEach(this::deleteFlow);
@@ -545,39 +737,48 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     protected void shouldNotIncrementRevisionOnUpdateGivenEqualSource() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         final List<Flow> toDelete = new ArrayList<>();
         final String flowId = IdUtils.create();
         try {
 
             // Given
-            FlowWithSource created = flowRepository.create(createTestingLogFlow(tenant, flowId, "first"));
+            FlowWithSource created = flowRepository.create(createTestingLogFlow(flowId, "first"));
             toDelete.add(created);
 
             // When
-            FlowWithSource updated = flowRepository.update(createTestingLogFlow(tenant, flowId, "first"), created);
+            FlowWithSource updated = flowRepository.update(createTestingLogFlow(flowId, "first"), created);
             toDelete.add(updated);
 
             // Then
             assertThat(updated.getRevision()).isEqualTo(1);
-            assertThat(flowRepository.lastRevision(tenant, TEST_NAMESPACE, flowId)).isEqualTo(1);
+            assertThat(flowRepository.lastRevision(TEST_TENANT_ID, TEST_NAMESPACE, flowId)).isEqualTo(1);
 
         } finally {
             toDelete.forEach(this::deleteFlow);
         }
     }
 
+    @Test
+    void shouldReturnForGivenQueryWildCardFilters() {
+        List<QueryFilter> filters = List.of(
+           QueryFilter.builder().field(QueryFilter.Field.QUERY).operation(QueryFilter.Op.EQUALS).value("*").build()
+        );
+        ArrayListTotal<Flow> flows = flowRepository.find(Pageable.from(1, 10), MAIN_TENANT, filters);
+        assertThat(flows.size()).isEqualTo(10);
+        assertThat(flows.getTotal()).isEqualTo(Helpers.FLOWS_COUNT);
+    }
+
     @Test
     void findByExecution() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        Flow flow = builder(tenant)
+        Flow flow = builder()
+            .tenantId(MAIN_TENANT)
             .revision(1)
             .build();
         flowRepository.create(GenericFlow.of(flow));
         Execution execution = Execution.builder()
             .id(IdUtils.create())
             .namespace(flow.getNamespace())
-            .tenantId(tenant)
+            .tenantId(MAIN_TENANT)
             .flowId(flow.getId())
             .flowRevision(flow.getRevision())
             .state(new State())
@@ -602,13 +803,11 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     void findByExecutionNoRevision() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        Flow flow = builder(tenant)
+        Flow flow = builder()
             .revision(3)
             .build();
         flowRepository.create(GenericFlow.of(flow));
         Execution execution = Execution.builder()
-            .tenantId(tenant)
             .id(IdUtils.create())
             .namespace(flow.getNamespace())
             .flowId(flow.getId())
@@ -634,14 +833,13 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     void shouldCountForNullTenant() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         FlowWithSource toDelete = null;
         try {
             // Given
-            Flow flow = createTestFlowForNamespace(tenant, TEST_NAMESPACE);
+            Flow flow = createTestFlowForNamespace(TEST_NAMESPACE);
             toDelete = flowRepository.create(GenericFlow.of(flow));
             // When
-            int count = flowRepository.count(tenant);
+            int count = flowRepository.count(MAIN_TENANT);
 
             // Then
             Assertions.assertTrue(count > 0);
@@ -652,11 +850,11 @@ public abstract class AbstractFlowRepositoryTest {
         }
     }
 
-    private static Flow createTestFlowForNamespace(String tenantId, String namespace) {
+    private static Flow createTestFlowForNamespace(String namespace) {
         return Flow.builder()
             .id(IdUtils.create())
             .namespace(namespace)
-            .tenantId(tenantId)
+            .tenantId(MAIN_TENANT)
             .tasks(List.of(Return.builder()
                 .id(IdUtils.create())
                 .type(Return.class.getName())
@@ -675,31 +873,21 @@ public abstract class AbstractFlowRepositoryTest {
     }
 
     @Singleton
-    public static class FlowListener implements ApplicationEventListener<CrudEvent<AbstractFlow>> {
-        private static List<CrudEvent<AbstractFlow>> emits = new CopyOnWriteArrayList<>();
+    public static class FlowListener implements ApplicationEventListener<CrudEvent<Flow>> {
+        @Getter
+        private static List<CrudEvent<Flow>> emits = new ArrayList<>();
 
         @Override
-        public void onApplicationEvent(CrudEvent<AbstractFlow> event) {
-            //This has to be done because Micronaut may send CrudEvent<Setting> for example, and we don't want them.
-            if ((event.getModel() != null && event.getModel() instanceof AbstractFlow)||
-                (event.getPreviousModel() != null && event.getPreviousModel() instanceof AbstractFlow)) {
-                emits.add(event);
-            }
+        public void onApplicationEvent(CrudEvent<Flow> event) {
+            emits.add(event);
         }
 
         public static void reset() {
-            emits = new CopyOnWriteArrayList<>();
-        }
-
-        public static List<CrudEvent<AbstractFlow>> filterByTenant(String tenantId){
-            return emits.stream()
-                .filter(e -> (e.getPreviousModel() != null && e.getPreviousModel().getTenantId().equals(tenantId)) ||
-                    (e.getModel() != null && e.getModel().getTenantId().equals(tenantId)))
-                .toList();
+            emits = new ArrayList<>();
         }
     }
 
-    private static GenericFlow createTestingLogFlow(String tenantId, String id, String logMessage) {
+    private static GenericFlow createTestingLogFlow(String id, String logMessage) {
         String source = """
                id: %s
                namespace: %s
@@ -708,7 +896,7 @@ public abstract class AbstractFlowRepositoryTest {
                    type: io.kestra.plugin.core.log.Log
                    message: %s
             """.formatted(id, TEST_NAMESPACE, logMessage);
-        return GenericFlow.fromYaml(tenantId, source);
+        return GenericFlow.fromYaml(TEST_TENANT_ID, source);
     }
 
     protected static int COUNTER = 0;

core/src/test/java/io/kestra/core/repositories/AbstractFlowTopologyRepositoryTest.java

@@ -4,7 +4,7 @@ import io.kestra.core.models.topologies.FlowNode;
 import io.kestra.core.models.topologies.FlowRelation;
 import io.kestra.core.models.topologies.FlowTopology;
 import io.kestra.core.junit.annotations.KestraTest;
-import io.kestra.core.utils.TestsUtils;
+import io.kestra.core.tenant.TenantService;
 import jakarta.inject.Inject;
 import org.junit.jupiter.api.Test;
 
@@ -17,21 +17,21 @@ public abstract class AbstractFlowTopologyRepositoryTest {
     @Inject
     private FlowTopologyRepositoryInterface flowTopologyRepository;
 
-    protected FlowTopology createSimpleFlowTopology(String tenantId, String flowA, String flowB, String namespace) {
+    protected FlowTopology createSimpleFlowTopology(String flowA, String flowB, String namespace) {
         return FlowTopology.builder()
             .relation(FlowRelation.FLOW_TASK)
             .source(FlowNode.builder()
                 .id(flowA)
                 .namespace(namespace)
-                .tenantId(tenantId)
-                .uid(tenantId + flowA)
+                .tenantId(TenantService.MAIN_TENANT)
+                .uid(flowA)
                 .build()
             )
             .destination(FlowNode.builder()
                 .id(flowB)
                 .namespace(namespace)
-                .tenantId(tenantId)
-                .uid(tenantId + flowB)
+                .tenantId(TenantService.MAIN_TENANT)
+                .uid(flowB)
                 .build()
             )
             .build();
@@ -39,45 +39,42 @@ public abstract class AbstractFlowTopologyRepositoryTest {
 
     @Test
     void findByFlow() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         flowTopologyRepository.save(
-            createSimpleFlowTopology(tenant, "flow-a", "flow-b", "io.kestra.tests")
+            createSimpleFlowTopology("flow-a", "flow-b", "io.kestra.tests")
         );
 
-        List<FlowTopology> list = flowTopologyRepository.findByFlow(tenant, "io.kestra.tests", "flow-a", false);
+        List<FlowTopology> list = flowTopologyRepository.findByFlow(TenantService.MAIN_TENANT, "io.kestra.tests", "flow-a", false);
 
         assertThat(list.size()).isEqualTo(1);
     }
 
     @Test
     void findByNamespace() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         flowTopologyRepository.save(
-            createSimpleFlowTopology(tenant, "flow-a", "flow-b", "io.kestra.tests")
+            createSimpleFlowTopology("flow-a", "flow-b", "io.kestra.tests")
         );
         flowTopologyRepository.save(
-            createSimpleFlowTopology(tenant, "flow-c", "flow-d", "io.kestra.tests")
+            createSimpleFlowTopology("flow-c", "flow-d", "io.kestra.tests")
         );
 
-        List<FlowTopology> list = flowTopologyRepository.findByNamespace(tenant, "io.kestra.tests");
+        List<FlowTopology> list = flowTopologyRepository.findByNamespace(TenantService.MAIN_TENANT, "io.kestra.tests");
 
         assertThat(list.size()).isEqualTo(2);
     }
 
     @Test
     void findAll() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         flowTopologyRepository.save(
-            createSimpleFlowTopology(tenant, "flow-a", "flow-b", "io.kestra.tests")
+            createSimpleFlowTopology("flow-a", "flow-b", "io.kestra.tests")
         );
         flowTopologyRepository.save(
-            createSimpleFlowTopology(tenant, "flow-c", "flow-d", "io.kestra.tests")
+            createSimpleFlowTopology("flow-c", "flow-d", "io.kestra.tests")
         );
         flowTopologyRepository.save(
-            createSimpleFlowTopology(tenant, "flow-e", "flow-f", "io.kestra.tests.2")
+            createSimpleFlowTopology("flow-e", "flow-f", "io.kestra.tests.2")
         );
 
-        List<FlowTopology> list = flowTopologyRepository.findAll(tenant);
+        List<FlowTopology> list = flowTopologyRepository.findAll(TenantService.MAIN_TENANT);
 
         assertThat(list.size()).isEqualTo(3);
     }

core/src/test/java/io/kestra/core/repositories/AbstractLogRepositoryTest.java

@@ -14,6 +14,7 @@ import io.kestra.core.models.flows.State;
 import io.kestra.core.repositories.ExecutionRepositoryInterface.ChildFilter;
 import io.kestra.core.utils.IdUtils;
 import io.kestra.core.utils.TestsUtils;
+import io.kestra.plugin.core.dashboard.data.Executions;
 import io.kestra.plugin.core.dashboard.data.Logs;
 import io.micronaut.data.model.Pageable;
 import jakarta.inject.Inject;
@@ -33,7 +34,9 @@ import java.util.stream.Stream;
 
 import static io.kestra.core.models.flows.FlowScope.SYSTEM;
 import static io.kestra.core.models.flows.FlowScope.USER;
+import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatReflectiveOperationException;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 @KestraTest
@@ -41,11 +44,11 @@ public abstract class AbstractLogRepositoryTest {
     @Inject
     protected LogRepositoryInterface logRepository;
 
-    protected static LogEntry.LogEntryBuilder logEntry(String tenantId, Level level) {
-        return logEntry(tenantId, level, IdUtils.create());
+    protected static LogEntry.LogEntryBuilder logEntry(Level level) {
+        return logEntry(level, IdUtils.create());
     }
 
-    protected static LogEntry.LogEntryBuilder logEntry(String tenantId, Level level, String executionId) {
+    protected static LogEntry.LogEntryBuilder logEntry(Level level, String executionId) {
         return LogEntry.builder()
             .flowId("flowId")
             .namespace("io.kestra.unittest")
@@ -56,7 +59,7 @@ public abstract class AbstractLogRepositoryTest {
             .timestamp(Instant.now())
             .level(level)
             .thread("")
-            .tenantId(tenantId)
+            .tenantId(MAIN_TENANT)
             .triggerId("triggerId")
             .message("john doe");
     }
@@ -64,10 +67,9 @@ public abstract class AbstractLogRepositoryTest {
     @ParameterizedTest
     @MethodSource("filterCombinations")
     void should_find_all(QueryFilter filter){
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        logRepository.save(logEntry(tenant, Level.INFO, "executionId").build());
+        logRepository.save(logEntry(Level.INFO, "executionId").build());
 
-        ArrayListTotal<LogEntry> entries = logRepository.find(Pageable.UNPAGED, tenant, List.of(filter));
+        ArrayListTotal<LogEntry> entries = logRepository.find(Pageable.UNPAGED, MAIN_TENANT, List.of(filter));
 
         assertThat(entries).hasSize(1);
     }
@@ -75,10 +77,9 @@ public abstract class AbstractLogRepositoryTest {
     @ParameterizedTest
     @MethodSource("filterCombinations")
     void should_find_async(QueryFilter filter){
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        logRepository.save(logEntry(tenant, Level.INFO, "executionId").build());
+        logRepository.save(logEntry(Level.INFO, "executionId").build());
 
-        Flux<LogEntry> find = logRepository.findAsync(tenant, List.of(filter));
+        Flux<LogEntry> find = logRepository.findAsync(MAIN_TENANT, List.of(filter));
 
         List<LogEntry> logEntries = find.collectList().block();
         assertThat(logEntries).hasSize(1);
@@ -87,12 +88,11 @@ public abstract class AbstractLogRepositoryTest {
     @ParameterizedTest
     @MethodSource("filterCombinations")
     void should_delete_with_filter(QueryFilter filter){
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        logRepository.save(logEntry(tenant, Level.INFO, "executionId").build());
+        logRepository.save(logEntry(Level.INFO, "executionId").build());
 
-        logRepository.deleteByFilters(tenant, List.of(filter));
+        logRepository.deleteByFilters(MAIN_TENANT, List.of(filter));
 
-        assertThat(logRepository.findAllAsync(tenant).collectList().block()).isEmpty();
+        assertThat(logRepository.findAllAsync(MAIN_TENANT).collectList().block()).isEmpty();
     }
 
 
@@ -152,10 +152,7 @@ public abstract class AbstractLogRepositoryTest {
     void should_fail_to_find_all(QueryFilter filter){
         assertThrows(
             InvalidQueryFiltersException.class,
-            () -> logRepository.find(
-                Pageable.UNPAGED,
-                TestsUtils.randomTenant(this.getClass().getSimpleName()),
-                List.of(filter)));
+            () -> logRepository.find(Pageable.UNPAGED, MAIN_TENANT, List.of(filter)));
 
     }
 
@@ -173,17 +170,16 @@ public abstract class AbstractLogRepositoryTest {
 
     @Test
     void all() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        LogEntry.LogEntryBuilder builder = logEntry(tenant, Level.INFO);
+        LogEntry.LogEntryBuilder builder = logEntry(Level.INFO);
 
-        ArrayListTotal<LogEntry> find = logRepository.find(Pageable.UNPAGED, tenant, null);
+        ArrayListTotal<LogEntry> find = logRepository.find(Pageable.UNPAGED, MAIN_TENANT, null);
         assertThat(find.size()).isZero();
 
 
         LogEntry save = logRepository.save(builder.build());
         logRepository.save(builder.executionKind(ExecutionKind.TEST).build()); // should only be loaded by execution id
 
-        find = logRepository.find(Pageable.UNPAGED, tenant, null);
+        find = logRepository.find(Pageable.UNPAGED, MAIN_TENANT, null);
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
         var filters = List.of(QueryFilter.builder()
@@ -199,7 +195,7 @@ public abstract class AbstractLogRepositoryTest {
         find = logRepository.find(Pageable.UNPAGED,  "doe", filters);
         assertThat(find.size()).isZero();
 
-        find = logRepository.find(Pageable.UNPAGED, tenant, null);
+        find = logRepository.find(Pageable.UNPAGED, MAIN_TENANT, null);
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
 
@@ -207,146 +203,141 @@ public abstract class AbstractLogRepositoryTest {
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
 
-        List<LogEntry> list = logRepository.findByExecutionId(tenant, save.getExecutionId(), null);
+        List<LogEntry> list = logRepository.findByExecutionId(MAIN_TENANT, save.getExecutionId(), null);
         assertThat(list.size()).isEqualTo(2);
         assertThat(list.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
 
-        list = logRepository.findByExecutionId(tenant, "io.kestra.unittest", "flowId", save.getExecutionId(), null);
+        list = logRepository.findByExecutionId(MAIN_TENANT, "io.kestra.unittest", "flowId", save.getExecutionId(), null);
         assertThat(list.size()).isEqualTo(2);
         assertThat(list.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
 
-        list = logRepository.findByExecutionIdAndTaskId(tenant, save.getExecutionId(), save.getTaskId(), null);
+        list = logRepository.findByExecutionIdAndTaskId(MAIN_TENANT, save.getExecutionId(), save.getTaskId(), null);
         assertThat(list.size()).isEqualTo(2);
         assertThat(list.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
 
-        list = logRepository.findByExecutionIdAndTaskId(tenant, "io.kestra.unittest", "flowId", save.getExecutionId(), save.getTaskId(), null);
+        list = logRepository.findByExecutionIdAndTaskId(MAIN_TENANT, "io.kestra.unittest", "flowId", save.getExecutionId(), save.getTaskId(), null);
         assertThat(list.size()).isEqualTo(2);
         assertThat(list.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
 
-        list = logRepository.findByExecutionIdAndTaskRunId(tenant, save.getExecutionId(), save.getTaskRunId(), null);
+        list = logRepository.findByExecutionIdAndTaskRunId(MAIN_TENANT, save.getExecutionId(), save.getTaskRunId(), null);
         assertThat(list.size()).isEqualTo(2);
         assertThat(list.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
 
-        list = logRepository.findByExecutionIdAndTaskRunIdAndAttempt(tenant, save.getExecutionId(), save.getTaskRunId(), null, 0);
+        list = logRepository.findByExecutionIdAndTaskRunIdAndAttempt(MAIN_TENANT, save.getExecutionId(), save.getTaskRunId(), null, 0);
         assertThat(list.size()).isEqualTo(2);
         assertThat(list.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
 
         Integer countDeleted = logRepository.purge(Execution.builder().id(save.getExecutionId()).build());
         assertThat(countDeleted).isEqualTo(2);
 
-        list = logRepository.findByExecutionIdAndTaskId(tenant, save.getExecutionId(), save.getTaskId(), null);
+        list = logRepository.findByExecutionIdAndTaskId(MAIN_TENANT, save.getExecutionId(), save.getTaskId(), null);
         assertThat(list.size()).isZero();
     }
 
     @Test
     void pageable() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         String executionId = "123";
-        LogEntry.LogEntryBuilder builder = logEntry(tenant, Level.INFO);
+        LogEntry.LogEntryBuilder builder = logEntry(Level.INFO);
         builder.executionId(executionId);
 
         for (int i = 0; i < 80; i++) {
             logRepository.save(builder.build());
         }
 
-        builder = logEntry(tenant, Level.INFO).executionId(executionId).taskId("taskId2").taskRunId("taskRunId2");
+        builder = logEntry(Level.INFO).executionId(executionId).taskId("taskId2").taskRunId("taskRunId2");
         LogEntry logEntry2 = logRepository.save(builder.build());
         for (int i = 0; i < 20; i++) {
             logRepository.save(builder.build());
         }
 
-        ArrayListTotal<LogEntry> find = logRepository.findByExecutionId(tenant, executionId, null, Pageable.from(1, 50));
+        ArrayListTotal<LogEntry> find = logRepository.findByExecutionId(MAIN_TENANT, executionId, null, Pageable.from(1, 50));
 
         assertThat(find.size()).isEqualTo(50);
         assertThat(find.getTotal()).isEqualTo(101L);
 
-        find = logRepository.findByExecutionId(tenant, executionId, null, Pageable.from(3, 50));
+        find = logRepository.findByExecutionId(MAIN_TENANT, executionId, null, Pageable.from(3, 50));
 
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getTotal()).isEqualTo(101L);
 
-        find = logRepository.findByExecutionIdAndTaskId(tenant, executionId, logEntry2.getTaskId(), null, Pageable.from(1, 50));
+        find = logRepository.findByExecutionIdAndTaskId(MAIN_TENANT, executionId, logEntry2.getTaskId(), null, Pageable.from(1, 50));
 
         assertThat(find.size()).isEqualTo(21);
         assertThat(find.getTotal()).isEqualTo(21L);
 
-        find = logRepository.findByExecutionIdAndTaskRunId(tenant, executionId, logEntry2.getTaskRunId(), null, Pageable.from(1, 10));
+        find = logRepository.findByExecutionIdAndTaskRunId(MAIN_TENANT, executionId, logEntry2.getTaskRunId(), null, Pageable.from(1, 10));
 
         assertThat(find.size()).isEqualTo(10);
         assertThat(find.getTotal()).isEqualTo(21L);
 
-        find = logRepository.findByExecutionIdAndTaskRunIdAndAttempt(tenant, executionId, logEntry2.getTaskRunId(), null, 0, Pageable.from(1, 10));
+        find = logRepository.findByExecutionIdAndTaskRunIdAndAttempt(MAIN_TENANT, executionId, logEntry2.getTaskRunId(), null, 0, Pageable.from(1, 10));
 
         assertThat(find.size()).isEqualTo(10);
         assertThat(find.getTotal()).isEqualTo(21L);
 
-        find = logRepository.findByExecutionIdAndTaskRunId(tenant, executionId, logEntry2.getTaskRunId(), null, Pageable.from(10, 10));
+        find = logRepository.findByExecutionIdAndTaskRunId(MAIN_TENANT, executionId, logEntry2.getTaskRunId(), null, Pageable.from(10, 10));
 
         assertThat(find.size()).isZero();
     }
 
     @Test
     void shouldFindByExecutionIdTestLogs() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        var builder = logEntry(tenant, Level.INFO).executionId("123").executionKind(ExecutionKind.TEST).build();
+        var builder = logEntry(Level.INFO).executionId("123").executionKind(ExecutionKind.TEST).build();
         logRepository.save(builder);
 
-        List<LogEntry> logs = logRepository.findByExecutionId(tenant, builder.getExecutionId(), null);
+        List<LogEntry> logs = logRepository.findByExecutionId(MAIN_TENANT, builder.getExecutionId(), null);
         assertThat(logs).hasSize(1);
     }
 
     @Test
     void deleteByQuery() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        LogEntry log1 = logEntry(tenant, Level.INFO).build();
+        LogEntry log1 = logEntry(Level.INFO).build();
         logRepository.save(log1);
 
-        logRepository.deleteByQuery(tenant, log1.getExecutionId(), null, null, null, null);
+        logRepository.deleteByQuery(MAIN_TENANT, log1.getExecutionId(), null, null, null, null);
 
-        ArrayListTotal<LogEntry> find = logRepository.findByExecutionId(tenant, log1.getExecutionId(), null, Pageable.from(1, 50));
+        ArrayListTotal<LogEntry> find = logRepository.findByExecutionId(MAIN_TENANT, log1.getExecutionId(), null, Pageable.from(1, 50));
         assertThat(find.size()).isZero();
 
         logRepository.save(log1);
 
-        logRepository.deleteByQuery(tenant, "io.kestra.unittest", "flowId", null, List.of(Level.TRACE, Level.DEBUG, Level.INFO), null, ZonedDateTime.now().plusMinutes(1));
+        logRepository.deleteByQuery(MAIN_TENANT, "io.kestra.unittest", "flowId", null, List.of(Level.TRACE, Level.DEBUG, Level.INFO), null, ZonedDateTime.now().plusMinutes(1));
 
-        find = logRepository.findByExecutionId(tenant, log1.getExecutionId(), null, Pageable.from(1, 50));
+        find = logRepository.findByExecutionId(MAIN_TENANT, log1.getExecutionId(), null, Pageable.from(1, 50));
         assertThat(find.size()).isZero();
 
         logRepository.save(log1);
 
-        logRepository.deleteByQuery(tenant, "io.kestra.unittest", "flowId", null);
+        logRepository.deleteByQuery(MAIN_TENANT, "io.kestra.unittest", "flowId", null);
 
-        find = logRepository.findByExecutionId(tenant, log1.getExecutionId(), null, Pageable.from(1, 50));
+        find = logRepository.findByExecutionId(MAIN_TENANT, log1.getExecutionId(), null, Pageable.from(1, 50));
         assertThat(find.size()).isZero();
 
         logRepository.save(log1);
 
-        logRepository.deleteByQuery(tenant, null, null, log1.getExecutionId(), List.of(Level.TRACE, Level.DEBUG, Level.INFO), null, ZonedDateTime.now().plusMinutes(1));
+        logRepository.deleteByQuery(MAIN_TENANT, null, null, log1.getExecutionId(), List.of(Level.TRACE, Level.DEBUG, Level.INFO), null, ZonedDateTime.now().plusMinutes(1));
 
-        find = logRepository.findByExecutionId(tenant, log1.getExecutionId(), null, Pageable.from(1, 50));
+        find = logRepository.findByExecutionId(MAIN_TENANT, log1.getExecutionId(), null, Pageable.from(1, 50));
         assertThat(find.size()).isZero();
     }
 
     @Test
     void findAllAsync() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        logRepository.save(logEntry(tenant, Level.INFO).build());
-        logRepository.save(logEntry(tenant, Level.INFO).executionKind(ExecutionKind.TEST).build()); // should be present as it's used for backup
-        logRepository.save(logEntry(tenant, Level.ERROR).build());
-        logRepository.save(logEntry(tenant, Level.WARN).build());
+        logRepository.save(logEntry(Level.INFO).build());
+        logRepository.save(logEntry(Level.INFO).executionKind(ExecutionKind.TEST).build()); // should be present as it's used for backup
+        logRepository.save(logEntry(Level.ERROR).build());
+        logRepository.save(logEntry(Level.WARN).build());
 
-        Flux<LogEntry> find = logRepository.findAllAsync(tenant);
+        Flux<LogEntry> find = logRepository.findAllAsync(MAIN_TENANT);
         List<LogEntry> logEntries = find.collectList().block();
         assertThat(logEntries).hasSize(4);
     }
 
     @Test
     void fetchData() throws IOException {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        logRepository.save(logEntry(tenant, Level.INFO).build());
+        logRepository.save(logEntry(Level.INFO).build());
 
-        var results = logRepository.fetchData(tenant,
+        var results = logRepository.fetchData(MAIN_TENANT,
             Logs.builder()
                 .type(Logs.class.getName())
                 .columns(Map.of(
@@ -359,4 +350,15 @@ public abstract class AbstractLogRepositoryTest {
 
         assertThat(results).hasSize(1);
     }
+
+    @Test
+    void purge() {
+        logRepository.save(logEntry(Level.INFO, "execution1").build());
+        logRepository.save(logEntry(Level.INFO, "execution1").build());
+        logRepository.save(logEntry(Level.INFO, "execution2").build());
+        logRepository.save(logEntry(Level.INFO, "execution2").build());
+
+        var result = logRepository.purge(List.of(Execution.builder().id("execution1").build(), Execution.builder().id("execution2").build()));
+        assertThat(result).isEqualTo(4);
+    }
 }

core/src/test/java/io/kestra/core/repositories/AbstractMetricRepositoryTest.java

@@ -1,17 +1,18 @@
 package io.kestra.core.repositories;
 
 import com.devskiller.friendly_id.FriendlyId;
+import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.executions.ExecutionKind;
 import io.kestra.core.models.executions.MetricEntry;
 import io.kestra.core.models.executions.TaskRun;
 import io.kestra.core.models.executions.metrics.Counter;
 import io.kestra.core.models.executions.metrics.MetricAggregations;
 import io.kestra.core.models.executions.metrics.Timer;
-import io.kestra.core.utils.TestsUtils;
 import io.micronaut.data.model.Pageable;
 import io.kestra.core.junit.annotations.KestraTest;
 import jakarta.inject.Inject;
 import org.junit.jupiter.api.Test;
+import org.slf4j.event.Level;
 
 import java.time.Duration;
 import java.time.ZonedDateTime;
@@ -26,28 +27,27 @@ public abstract class AbstractMetricRepositoryTest {
 
     @Test
     void all() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         String executionId = FriendlyId.createFriendlyId();
-        TaskRun taskRun1 = taskRun(tenant, executionId, "task");
+        TaskRun taskRun1 = taskRun(executionId, "task");
         MetricEntry counter = MetricEntry.of(taskRun1, counter("counter"), null);
         MetricEntry testCounter = MetricEntry.of(taskRun1, counter("test"), ExecutionKind.TEST);
-        TaskRun taskRun2 = taskRun(tenant, executionId, "task");
+        TaskRun taskRun2 = taskRun(executionId, "task");
         MetricEntry timer = MetricEntry.of(taskRun2, timer(), null);
         metricRepository.save(counter);
         metricRepository.save(testCounter); // should only be retrieved by execution id
         metricRepository.save(timer);
 
-        List<MetricEntry> results = metricRepository.findByExecutionId(tenant, executionId, Pageable.from(1, 10));
+        List<MetricEntry> results = metricRepository.findByExecutionId(null, executionId, Pageable.from(1, 10));
         assertThat(results.size()).isEqualTo(3);
 
-        results = metricRepository.findByExecutionIdAndTaskId(tenant, executionId, taskRun1.getTaskId(), Pageable.from(1, 10));
+        results = metricRepository.findByExecutionIdAndTaskId(null, executionId, taskRun1.getTaskId(), Pageable.from(1, 10));
         assertThat(results.size()).isEqualTo(3);
 
-        results = metricRepository.findByExecutionIdAndTaskRunId(tenant, executionId, taskRun1.getId(), Pageable.from(1, 10));
+        results = metricRepository.findByExecutionIdAndTaskRunId(null, executionId, taskRun1.getId(), Pageable.from(1, 10));
         assertThat(results.size()).isEqualTo(2);
 
         MetricAggregations aggregationResults = metricRepository.aggregateByFlowId(
-            tenant,
+            null,
             "namespace",
             "flow",
             null,
@@ -61,7 +61,7 @@ public abstract class AbstractMetricRepositoryTest {
         assertThat(aggregationResults.getGroupBy()).isEqualTo("day");
 
         aggregationResults = metricRepository.aggregateByFlowId(
-            tenant,
+            null,
             "namespace",
             "flow",
             null,
@@ -78,12 +78,11 @@ public abstract class AbstractMetricRepositoryTest {
 
      @Test
      void names() {
-         String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
          String executionId = FriendlyId.createFriendlyId();
-         TaskRun taskRun1 = taskRun(tenant, executionId, "task");
+         TaskRun taskRun1 = taskRun(executionId, "task");
          MetricEntry counter = MetricEntry.of(taskRun1, counter("counter"), null);
 
-         TaskRun taskRun2 = taskRun(tenant, executionId, "task2");
+         TaskRun taskRun2 = taskRun(executionId, "task2");
          MetricEntry counter2 = MetricEntry.of(taskRun2, counter("counter2"), null);
 
          MetricEntry test = MetricEntry.of(taskRun2, counter("test"), ExecutionKind.TEST);
@@ -93,9 +92,9 @@ public abstract class AbstractMetricRepositoryTest {
          metricRepository.save(test); // should only be retrieved by execution id
 
 
-         List<String> flowMetricsNames = metricRepository.flowMetrics(tenant, "namespace", "flow");
-         List<String> taskMetricsNames = metricRepository.taskMetrics(tenant, "namespace", "flow", "task");
-         List<String> tasksWithMetrics = metricRepository.tasksWithMetrics(tenant, "namespace", "flow");
+         List<String> flowMetricsNames = metricRepository.flowMetrics(null, "namespace", "flow");
+         List<String> taskMetricsNames = metricRepository.taskMetrics(null, "namespace", "flow", "task");
+         List<String> tasksWithMetrics = metricRepository.tasksWithMetrics(null, "namespace", "flow");
 
          assertThat(flowMetricsNames.size()).isEqualTo(2);
          assertThat(taskMetricsNames.size()).isEqualTo(1);
@@ -104,21 +103,31 @@ public abstract class AbstractMetricRepositoryTest {
 
     @Test
     void findAllAsync() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         String executionId = FriendlyId.createFriendlyId();
-        TaskRun taskRun1 = taskRun(tenant, executionId, "task");
+        TaskRun taskRun1 = taskRun(executionId, "task");
         MetricEntry counter = MetricEntry.of(taskRun1, counter("counter"), null);
-        TaskRun taskRun2 = taskRun(tenant, executionId, "task");
+        TaskRun taskRun2 = taskRun(executionId, "task");
         MetricEntry timer = MetricEntry.of(taskRun2, timer(), null);
         MetricEntry test = MetricEntry.of(taskRun2, counter("test"), ExecutionKind.TEST);
         metricRepository.save(counter);
         metricRepository.save(timer);
         metricRepository.save(test); // should be retrieved as findAllAsync is used for backup
 
-        List<MetricEntry> results = metricRepository.findAllAsync(tenant).collectList().block();
+        List<MetricEntry> results = metricRepository.findAllAsync(null).collectList().block();
         assertThat(results).hasSize(3);
     }
 
+    @Test
+    void purge() {
+        metricRepository.save(MetricEntry.of(taskRun("execution1", "task"), counter("counter1"), null));
+        metricRepository.save(MetricEntry.of(taskRun("execution1", "task"), counter("counter2"), null));
+        metricRepository.save(MetricEntry.of(taskRun("execution2", "task"), counter("counter1"), null));
+        metricRepository.save(MetricEntry.of(taskRun("execution2", "task"), counter("counter2"), null));
+
+        var result = metricRepository.purge(List.of(Execution.builder().id("execution1").build(), Execution.builder().id("execution2").build()));
+        assertThat(result).isEqualTo(4);
+    }
+
     private Counter counter(String metricName) {
         return Counter.of(metricName, 1);
     }
@@ -127,9 +136,8 @@ public abstract class AbstractMetricRepositoryTest {
         return Timer.of("counter", Duration.ofSeconds(5));
     }
 
-    private TaskRun taskRun(String tenantId, String executionId, String taskId) {
+    private TaskRun taskRun(String executionId, String taskId) {
         return TaskRun.builder()
-            .tenantId(tenantId)
             .flowId("flow")
             .namespace("namespace")
             .executionId(executionId)

core/src/test/java/io/kestra/core/repositories/AbstractTemplateRepositoryTest.java

@@ -4,8 +4,6 @@ import io.kestra.core.events.CrudEvent;
 import io.kestra.core.events.CrudEventType;
 import io.kestra.core.models.property.Property;
 import io.kestra.core.models.templates.Template;
-import io.kestra.core.utils.Await;
-import io.kestra.core.utils.TestsUtils;
 import io.kestra.plugin.core.debug.Return;
 import io.kestra.core.utils.IdUtils;
 import io.micronaut.context.event.ApplicationEventListener;
@@ -13,10 +11,7 @@ import io.micronaut.data.model.Pageable;
 import io.kestra.core.junit.annotations.KestraTest;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
-import java.time.Duration;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.concurrent.TimeoutException;
-import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
@@ -25,8 +20,6 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -35,60 +28,55 @@ public abstract class AbstractTemplateRepositoryTest {
     @Inject
     protected TemplateRepositoryInterface templateRepository;
 
-    @BeforeAll
-    protected static void init() throws IOException, URISyntaxException {
+    @BeforeEach
+    protected void init() throws IOException, URISyntaxException {
         TemplateListener.reset();
     }
 
-    protected static Template.TemplateBuilder<?, ?> builder(String tenantId) {
-        return builder(tenantId, null);
+    protected static Template.TemplateBuilder<?, ?> builder() {
+        return builder(null);
     }
 
-    protected static Template.TemplateBuilder<?, ?> builder(String tenantId, String namespace) {
+    protected static Template.TemplateBuilder<?, ?> builder(String namespace) {
         return Template.builder()
             .id(IdUtils.create())
             .namespace(namespace == null ? "kestra.test" : namespace)
-            .tenantId(tenantId)
             .tasks(Collections.singletonList(Return.builder().id("test").type(Return.class.getName()).format(Property.ofValue("test")).build()));
     }
 
     @Test
     void findById() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        Template template = builder(tenant).build();
+        Template template = builder().build();
         templateRepository.create(template);
 
-        Optional<Template> full = templateRepository.findById(tenant, template.getNamespace(), template.getId());
+        Optional<Template> full = templateRepository.findById(null, template.getNamespace(), template.getId());
         assertThat(full.isPresent()).isTrue();
         assertThat(full.get().getId()).isEqualTo(template.getId());
 
-        full = templateRepository.findById(tenant, template.getNamespace(), template.getId());
+        full = templateRepository.findById(null, template.getNamespace(), template.getId());
         assertThat(full.isPresent()).isTrue();
         assertThat(full.get().getId()).isEqualTo(template.getId());
     }
 
     @Test
     void findByNamespace() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        Template template1 = builder(tenant).build();
+        Template template1 = builder().build();
         Template template2 = Template.builder()
             .id(IdUtils.create())
-            .tenantId(tenant)
             .namespace("kestra.test.template").build();
 
         templateRepository.create(template1);
         templateRepository.create(template2);
 
-        List<Template> templates = templateRepository.findByNamespace(tenant, template1.getNamespace());
+        List<Template> templates = templateRepository.findByNamespace(null, template1.getNamespace());
         assertThat(templates.size()).isGreaterThanOrEqualTo(1);
-        templates = templateRepository.findByNamespace(tenant, template2.getNamespace());
+        templates = templateRepository.findByNamespace(null, template2.getNamespace());
         assertThat(templates.size()).isEqualTo(1);
     }
 
     @Test
     void save() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        Template template = builder(tenant).build();
+        Template template = builder().build();
         Template save = templateRepository.create(template);
 
         assertThat(save.getId()).isEqualTo(template.getId());
@@ -96,42 +84,41 @@ public abstract class AbstractTemplateRepositoryTest {
 
     @Test
     void findAll() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        long saveCount = templateRepository.findAll(tenant).size();
-        Template template = builder(tenant).build();
+        long saveCount = templateRepository.findAll(null).size();
+        Template template = builder().build();
         templateRepository.create(template);
-        long size = templateRepository.findAll(tenant).size();
+        long size = templateRepository.findAll(null).size();
         assertThat(size).isGreaterThan(saveCount);
         templateRepository.delete(template);
-        assertThat((long) templateRepository.findAll(tenant).size()).isEqualTo(saveCount);
+        assertThat((long) templateRepository.findAll(null).size()).isEqualTo(saveCount);
     }
 
     @Test
     void findAllForAllTenants() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         long saveCount = templateRepository.findAllForAllTenants().size();
-        Template template = builder(tenant).build();
+        Template template = builder().build();
         templateRepository.create(template);
         long size = templateRepository.findAllForAllTenants().size();
         assertThat(size).isGreaterThan(saveCount);
+        templateRepository.delete(template);
+        assertThat((long) templateRepository.findAllForAllTenants().size()).isEqualTo(saveCount);
     }
 
     @Test
     void find() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        Template template1 = builder(tenant).build();
+        Template template1 = builder().build();
         templateRepository.create(template1);
-        Template template2 = builder(tenant).build();
+        Template template2 = builder().build();
         templateRepository.create(template2);
-        Template template3 = builder(tenant).build();
+        Template template3 = builder().build();
         templateRepository.create(template3);
 
         // with pageable
-        List<Template> save = templateRepository.find(Pageable.from(1, 10),null, tenant, "kestra.test");
+        List<Template> save = templateRepository.find(Pageable.from(1, 10),null, null, "kestra.test");
         assertThat((long) save.size()).isGreaterThanOrEqualTo(3L);
 
         // without pageable
-        save = templateRepository.find(null, tenant, "kestra.test");
+        save = templateRepository.find(null, null, "kestra.test");
         assertThat((long) save.size()).isGreaterThanOrEqualTo(3L);
 
         templateRepository.delete(template1);
@@ -139,45 +126,31 @@ public abstract class AbstractTemplateRepositoryTest {
         templateRepository.delete(template3);
     }
 
-    private static final Logger LOG = LoggerFactory.getLogger(AbstractTemplateRepositoryTest.class);
-
     @Test
-    protected void delete() throws TimeoutException {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        Template template = builder(tenant).build();
+    void delete() {
+        Template template = builder().build();
 
         Template save = templateRepository.create(template);
         templateRepository.delete(save);
 
-        assertThat(templateRepository.findById(tenant, template.getNamespace(), template.getId()).isPresent()).isFalse();
+        assertThat(templateRepository.findById(null, template.getNamespace(), template.getId()).isPresent()).isFalse();
 
-        Await.until(() -> {
-            LOG.info("-------------> number of event: {}", TemplateListener.getEmits(tenant).size());
-            return TemplateListener.getEmits(tenant).size() == 2;
-
-        }, Duration.ofMillis(100), Duration.ofSeconds(5));
-        assertThat(TemplateListener.getEmits(tenant).stream().filter(r -> r.getType() == CrudEventType.CREATE).count()).isEqualTo(1L);
-        assertThat(TemplateListener.getEmits(tenant).stream().filter(r -> r.getType() == CrudEventType.DELETE).count()).isEqualTo(1L);
+        assertThat(TemplateListener.getEmits().size()).isEqualTo(2);
+        assertThat(TemplateListener.getEmits().stream().filter(r -> r.getType() == CrudEventType.CREATE).count()).isEqualTo(1L);
+        assertThat(TemplateListener.getEmits().stream().filter(r -> r.getType() == CrudEventType.DELETE).count()).isEqualTo(1L);
     }
 
     @Singleton
     public static class TemplateListener implements ApplicationEventListener<CrudEvent<Template>> {
-        private static List<CrudEvent<Template>> emits = new CopyOnWriteArrayList<>();
+        private static List<CrudEvent<Template>> emits = new ArrayList<>();
 
         @Override
         public void onApplicationEvent(CrudEvent<Template> event) {
-            //The instanceOf is required because Micronaut may send non Template event via this method
-            if ((event.getModel() != null && event.getModel() instanceof Template) ||
-                    (event.getPreviousModel() != null && event.getPreviousModel() instanceof Template)) {
-                emits.add(event);
-            }
+            emits.add(event);
         }
 
-        public static List<CrudEvent<Template>> getEmits(String tenantId){
-            return emits.stream()
-                .filter(e -> (e.getModel() != null && e.getModel().getTenantId().equals(tenantId)) ||
-                    (e.getPreviousModel() != null && e.getPreviousModel().getTenantId().equals(tenantId)))
-                .toList();
+        public static List<CrudEvent<Template>> getEmits() {
+            return emits;
         }
 
         public static void reset() {

core/src/test/java/io/kestra/core/repositories/AbstractTriggerRepositoryTest.java

@@ -9,7 +9,6 @@ import io.kestra.core.models.flows.State;
 import io.kestra.core.models.triggers.Trigger;
 import io.kestra.core.repositories.ExecutionRepositoryInterface.ChildFilter;
 import io.kestra.core.utils.IdUtils;
-import io.kestra.core.utils.TestsUtils;
 import io.micronaut.data.model.Pageable;
 import io.micronaut.data.model.Sort;
 import jakarta.inject.Inject;
@@ -25,6 +24,7 @@ import java.util.Optional;
 import java.util.stream.Stream;
 
 import static io.kestra.core.models.flows.FlowScope.USER;
+import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
@@ -35,9 +35,8 @@ public abstract class AbstractTriggerRepositoryTest {
     @Inject
     protected TriggerRepositoryInterface triggerRepository;
 
-    private static Trigger.TriggerBuilder<?, ?> trigger(String tenantId) {
+    private static Trigger.TriggerBuilder<?, ?> trigger() {
         return Trigger.builder()
-            .tenantId(tenantId)
             .flowId(IdUtils.create())
             .namespace(TEST_NAMESPACE)
             .triggerId(IdUtils.create())
@@ -45,9 +44,9 @@ public abstract class AbstractTriggerRepositoryTest {
             .date(ZonedDateTime.now());
     }
 
-    protected static Trigger generateDefaultTrigger(String tenantId){
+    protected static Trigger generateDefaultTrigger(){
         Trigger trigger = Trigger.builder()
-            .tenantId(tenantId)
+            .tenantId(MAIN_TENANT)
             .triggerId("triggerId")
             .namespace("trigger.namespace")
             .flowId("flowId")
@@ -60,10 +59,9 @@ public abstract class AbstractTriggerRepositoryTest {
     @ParameterizedTest
     @MethodSource("filterCombinations")
     void should_find_all(QueryFilter filter){
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        triggerRepository.save(generateDefaultTrigger(tenant));
+        triggerRepository.save(generateDefaultTrigger());
 
-        ArrayListTotal<Trigger> entries = triggerRepository.find(Pageable.UNPAGED, tenant, List.of(filter));
+        ArrayListTotal<Trigger> entries = triggerRepository.find(Pageable.UNPAGED, MAIN_TENANT, List.of(filter));
 
         assertThat(entries).hasSize(1);
     }
@@ -71,10 +69,9 @@ public abstract class AbstractTriggerRepositoryTest {
     @ParameterizedTest
     @MethodSource("filterCombinations")
     void should_find_all_async(QueryFilter filter){
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        triggerRepository.save(generateDefaultTrigger(tenant));
+        triggerRepository.save(generateDefaultTrigger());
 
-        List<Trigger> entries = triggerRepository.find(tenant, List.of(filter)).collectList().block();
+        List<Trigger> entries = triggerRepository.find(MAIN_TENANT, List.of(filter)).collectList().block();
 
         assertThat(entries).hasSize(1);
     }
@@ -95,7 +92,7 @@ public abstract class AbstractTriggerRepositoryTest {
     @ParameterizedTest
     @MethodSource("errorFilterCombinations")
     void should_fail_to_find_all(QueryFilter filter){
-        assertThrows(InvalidQueryFiltersException.class, () -> triggerRepository.find(Pageable.UNPAGED, TestsUtils.randomTenant(this.getClass().getSimpleName()), List.of(filter)));
+        assertThrows(InvalidQueryFiltersException.class, () -> triggerRepository.find(Pageable.UNPAGED, MAIN_TENANT, List.of(filter)));
     }
 
     static Stream<QueryFilter> errorFilterCombinations() {
@@ -113,8 +110,7 @@ public abstract class AbstractTriggerRepositoryTest {
 
     @Test
     void all() {
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
-        Trigger.TriggerBuilder<?, ?> builder = trigger(tenant);
+        Trigger.TriggerBuilder<?, ?> builder = trigger();
 
         Optional<Trigger> findLast = triggerRepository.findLast(builder.build());
         assertThat(findLast.isPresent()).isFalse();
@@ -134,47 +130,47 @@ public abstract class AbstractTriggerRepositoryTest {
         assertThat(findLast.get().getExecutionId()).isEqualTo(save.getExecutionId());
 
 
-        triggerRepository.save(trigger(tenant).build());
-        triggerRepository.save(trigger(tenant).build());
-        Trigger searchedTrigger = trigger(tenant).build();
+        triggerRepository.save(trigger().build());
+        triggerRepository.save(trigger().build());
+        Trigger searchedTrigger = trigger().build();
         triggerRepository.save(searchedTrigger);
 
         List<Trigger> all = triggerRepository.findAllForAllTenants();
 
-        assertThat(all.size()).isGreaterThanOrEqualTo(4);
+        assertThat(all.size()).isEqualTo(4);
 
-        all = triggerRepository.findAll(tenant);
+        all = triggerRepository.findAll(null);
 
         assertThat(all.size()).isEqualTo(4);
 
         String namespacePrefix = "io.kestra.another";
         String namespace = namespacePrefix + ".ns";
-        Trigger trigger = trigger(tenant).namespace(namespace).build();
+        Trigger trigger = trigger().namespace(namespace).build();
         triggerRepository.save(trigger);
 
-        List<Trigger> find = triggerRepository.find(Pageable.from(1, 4, Sort.of(Sort.Order.asc("namespace"))), null, tenant, null, null, null);
+        List<Trigger> find = triggerRepository.find(Pageable.from(1, 4, Sort.of(Sort.Order.asc("namespace"))), null, null, null, null, null);
         assertThat(find.size()).isEqualTo(4);
         assertThat(find.getFirst().getNamespace()).isEqualTo(namespace);
 
-        find = triggerRepository.find(Pageable.from(1, 4, Sort.of(Sort.Order.asc("namespace"))), null, tenant, null, searchedTrigger.getFlowId(), null);
+        find = triggerRepository.find(Pageable.from(1, 4, Sort.of(Sort.Order.asc("namespace"))), null, null, null, searchedTrigger.getFlowId(), null);
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getFlowId()).isEqualTo(searchedTrigger.getFlowId());
 
-        find = triggerRepository.find(Pageable.from(1, 100, Sort.of(Sort.Order.asc(triggerRepository.sortMapping().apply("triggerId")))), null, tenant, namespacePrefix, null, null);
+        find = triggerRepository.find(Pageable.from(1, 100, Sort.of(Sort.Order.asc(triggerRepository.sortMapping().apply("triggerId")))), null, null, namespacePrefix, null, null);
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getTriggerId()).isEqualTo(trigger.getTriggerId());
 
         // Full text search is on namespace, flowId, triggerId, executionId
-        find = triggerRepository.find(Pageable.from(1, 100, Sort.UNSORTED), trigger.getNamespace(), tenant, null, null, null);
+        find = triggerRepository.find(Pageable.from(1, 100, Sort.UNSORTED), trigger.getNamespace(), null, null, null, null);
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getTriggerId()).isEqualTo(trigger.getTriggerId());
-        find = triggerRepository.find(Pageable.from(1, 100, Sort.UNSORTED), searchedTrigger.getFlowId(), tenant, null, null, null);
+        find = triggerRepository.find(Pageable.from(1, 100, Sort.UNSORTED), searchedTrigger.getFlowId(), null, null, null, null);
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getTriggerId()).isEqualTo(searchedTrigger.getTriggerId());
-        find = triggerRepository.find(Pageable.from(1, 100, Sort.UNSORTED), searchedTrigger.getTriggerId(), tenant, null, null, null);
+        find = triggerRepository.find(Pageable.from(1, 100, Sort.UNSORTED), searchedTrigger.getTriggerId(), null, null, null, null);
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getTriggerId()).isEqualTo(searchedTrigger.getTriggerId());
-        find = triggerRepository.find(Pageable.from(1, 100, Sort.UNSORTED), searchedTrigger.getExecutionId(), tenant, null, null, null);
+        find = triggerRepository.find(Pageable.from(1, 100, Sort.UNSORTED), searchedTrigger.getExecutionId(), null, null, null, null);
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getTriggerId()).isEqualTo(searchedTrigger.getTriggerId());
     }
@@ -182,17 +178,15 @@ public abstract class AbstractTriggerRepositoryTest {
     @Test
     void shouldCountForNullTenant() {
         // Given
-        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         triggerRepository.save(Trigger
             .builder()
-            .tenantId(tenant)
             .triggerId(IdUtils.create())
             .flowId(IdUtils.create())
             .namespace("io.kestra.unittest")
             .build()
         );
         // When
-        int count = triggerRepository.count(tenant);
+        int count = triggerRepository.count(null);
         // Then
         assertThat(count).isEqualTo(1);
     }

core/src/test/java/io/kestra/core/repositories/ExecutionFixture.java

@@ -1,92 +1,88 @@
 package io.kestra.core.repositories;
 
+import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
+
 import com.google.common.collect.ImmutableMap;
 import io.kestra.core.models.executions.*;
 import io.kestra.core.models.flows.State;
 import io.kestra.core.utils.IdUtils;
 
+import java.time.Duration;
 import java.util.Collections;
 
 class ExecutionFixture {
-    public static Execution EXECUTION_1(String tenant) {
-        return Execution.builder()
-            .id(IdUtils.create())
-            .namespace("io.kestra.unittest")
-            .tenantId(tenant)
-            .flowId("full")
-            .flowRevision(1)
-            .state(new State())
-            .inputs(ImmutableMap.of("test", "value"))
-            .taskRunList(Collections.singletonList(
-                TaskRun.builder()
-                    .id(IdUtils.create())
-                    .namespace("io.kestra.unittest")
-                    .flowId("full")
-                    .state(new State())
-                    .attempts(Collections.singletonList(
-                        TaskRunAttempt.builder()
-                            .build()
-                    ))
-                    .outputs(Variables.inMemory(ImmutableMap.of(
-                        "out", "value"
-                    )))
-                    .build()
-            ))
-            .build();
-    }
+    public static final Execution EXECUTION_1 = Execution.builder()
+        .id(IdUtils.create())
+        .namespace("io.kestra.unittest")
+        .tenantId(MAIN_TENANT)
+        .flowId("full")
+        .flowRevision(1)
+        .state(new State())
+        .inputs(ImmutableMap.of("test", "value"))
+        .taskRunList(Collections.singletonList(
+            TaskRun.builder()
+                .id(IdUtils.create())
+                .namespace("io.kestra.unittest")
+                .flowId("full")
+                .state(new State())
+                .attempts(Collections.singletonList(
+                    TaskRunAttempt.builder()
+                        .build()
+                ))
+                .outputs(Variables.inMemory(ImmutableMap.of(
+                    "out", "value"
+                )))
+                .build()
+        ))
+        .build();
 
-    public static Execution EXECUTION_2(String tenant) {
-        return Execution.builder()
-            .id(IdUtils.create())
-            .namespace("io.kestra.unittest")
-            .tenantId(tenant)
-            .flowId("full")
-            .flowRevision(1)
-            .state(new State())
-            .inputs(ImmutableMap.of("test", 1))
-            .taskRunList(Collections.singletonList(
-                TaskRun.builder()
-                    .id(IdUtils.create())
-                    .namespace("io.kestra.unittest")
-                    .flowId("full")
-                    .state(new State())
-                    .attempts(Collections.singletonList(
-                        TaskRunAttempt.builder()
-                            .build()
-                    ))
-                    .outputs(Variables.inMemory(ImmutableMap.of(
-                        "out", 1
-                    )))
-                    .build()
-            ))
-            .build();
-    }
+    public static final Execution EXECUTION_2 = Execution.builder()
+        .id(IdUtils.create())
+        .namespace("io.kestra.unittest")
+        .tenantId(MAIN_TENANT)
+        .flowId("full")
+        .flowRevision(1)
+        .state(new State())
+        .inputs(ImmutableMap.of("test", 1))
+        .taskRunList(Collections.singletonList(
+            TaskRun.builder()
+                .id(IdUtils.create())
+                .namespace("io.kestra.unittest")
+                .flowId("full")
+                .state(new State())
+                .attempts(Collections.singletonList(
+                    TaskRunAttempt.builder()
+                        .build()
+                ))
+                .outputs(Variables.inMemory(ImmutableMap.of(
+                    "out", 1
+                )))
+                .build()
+        ))
+        .build();
 
-    public static Execution EXECUTION_TEST(String tenant) {
-        return Execution.builder()
-            .id(IdUtils.create())
-            .namespace("io.kestra.unittest")
-            .tenantId(tenant)
-            .flowId("full")
-            .flowRevision(1)
-            .state(new State())
-            .inputs(ImmutableMap.of("test", 1))
-            .kind(ExecutionKind.TEST)
-            .taskRunList(Collections.singletonList(
-                TaskRun.builder()
-                    .id(IdUtils.create())
-                    .namespace("io.kestra.unittest")
-                    .flowId("full")
-                    .state(new State())
-                    .attempts(Collections.singletonList(
-                        TaskRunAttempt.builder()
-                            .build()
-                    ))
-                    .outputs(Variables.inMemory(ImmutableMap.of(
-                        "out", 1
-                    )))
-                    .build()
-            ))
-            .build();
-    }
-}
+    public static final Execution EXECUTION_TEST = Execution.builder()
+        .id(IdUtils.create())
+        .namespace("io.kestra.unittest")
+        .flowId("full")
+        .flowRevision(1)
+        .state(new State())
+        .inputs(ImmutableMap.of("test", 1))
+        .kind(ExecutionKind.TEST)
+        .taskRunList(Collections.singletonList(
+            TaskRun.builder()
+                .id(IdUtils.create())
+                .namespace("io.kestra.unittest")
+                .flowId("full")
+                .state(new State())
+                .attempts(Collections.singletonList(
+                    TaskRunAttempt.builder()
+                        .build()
+                ))
+                .outputs(Variables.inMemory(ImmutableMap.of(
+                    "out", 1
+                )))
+                .build()
+        ))
+        .build();
+}

core/src/test/java/io/kestra/core/runners/AbstractRunnerTest.java

@@ -1,6 +1,10 @@
 package io.kestra.core.runners;
 
+import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
+import static org.assertj.core.api.Assertions.assertThat;
+
 import io.kestra.core.junit.annotations.ExecuteFlow;
+import io.kestra.core.junit.annotations.FlakyTest;
 import io.kestra.core.junit.annotations.KestraTest;
 import io.kestra.core.junit.annotations.LoadFlows;
 import io.kestra.core.models.executions.Execution;
@@ -9,36 +13,36 @@ import io.kestra.core.models.flows.State;
 import io.kestra.core.queues.QueueException;
 import io.kestra.core.queues.QueueFactoryInterface;
 import io.kestra.core.queues.QueueInterface;
-import io.kestra.plugin.core.flow.*;
+import io.kestra.plugin.core.flow.EachSequentialTest;
+import io.kestra.plugin.core.flow.FlowCaseTest;
+import io.kestra.plugin.core.flow.ForEachItemCaseTest;
+import io.kestra.plugin.core.flow.PauseTest;
+import io.kestra.plugin.core.flow.LoopUntilCaseTest;
+import io.kestra.plugin.core.flow.WorkingDirectoryTest;
 import jakarta.inject.Inject;
 import jakarta.inject.Named;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.TestInstance;
-
 import java.util.Map;
 import java.util.concurrent.TimeoutException;
 
-import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
-import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junitpioneer.jupiter.RetryingTest;
 
 @KestraTest(startRunner = true)
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
-//@org.junit.jupiter.api.parallel.Execution(org.junit.jupiter.api.parallel.ExecutionMode.CONCURRENT)
 // must be per-class to allow calling once init() which took a lot of time
 public abstract class AbstractRunnerTest {
 
-    public static final String TENANT_1 = "tenant1";
-    public static final String TENANT_2 = "tenant2";
     @Inject
-    protected TestRunnerUtils runnerUtils;
+    protected RunnerUtils runnerUtils;
 
     @Inject
     @Named(QueueFactoryInterface.WORKERTASKLOG_NAMED)
     protected QueueInterface<LogEntry> logsQueue;
 
     @Inject
-    protected RestartCaseTest restartCaseTest;
+    private RestartCaseTest restartCaseTest;
 
     @Inject
     protected FlowTriggerCaseTest flowTriggerCaseTest;
@@ -50,13 +54,13 @@ public abstract class AbstractRunnerTest {
     private PluginDefaultsCaseTest pluginDefaultsCaseTest;
 
     @Inject
-    protected FlowCaseTest flowCaseTest;
+    private FlowCaseTest flowCaseTest;
 
     @Inject
     private WorkingDirectoryTest.Suite workingDirectoryTest;
 
     @Inject
-    protected PauseTest.Suite pauseTest;
+    private PauseTest.Suite pauseTest;
 
     @Inject
     private SkipExecutionCaseTest skipExecutionCaseTest;
@@ -68,10 +72,10 @@ public abstract class AbstractRunnerTest {
     protected LoopUntilCaseTest loopUntilTestCaseTest;
 
     @Inject
-    protected FlowConcurrencyCaseTest flowConcurrencyCaseTest;
+    private FlowConcurrencyCaseTest flowConcurrencyCaseTest;
 
     @Inject
-    protected ScheduleDateCaseTest scheduleDateCaseTest;
+    private ScheduleDateCaseTest scheduleDateCaseTest;
 
     @Inject
     protected FlowInputOutput flowIO;
@@ -80,7 +84,7 @@ public abstract class AbstractRunnerTest {
     private SLATestCase slaTestCase;
 
     @Inject
-    protected ChangeStateTestCase changeStateTestCase;
+    private ChangeStateTestCase changeStateTestCase;
 
     @Inject
     private AfterExecutionTestCase afterExecutionTestCase;
@@ -111,7 +115,7 @@ public abstract class AbstractRunnerTest {
         assertThat(execution.getTaskRunList()).hasSize(8);
     }
 
-    @Test
+    @RetryingTest(5)
     @ExecuteFlow("flows/valids/parallel-nested.yaml")
     void parallelNested(Execution execution) {
         assertThat(execution.getTaskRunList()).hasSize(11);
@@ -153,27 +157,27 @@ public abstract class AbstractRunnerTest {
         restartCaseTest.restartFailedThenSuccess();
     }
 
-    @Test
+    @RetryingTest(5)
     @LoadFlows({"flows/valids/restart-each.yaml"})
     void replay() throws Exception {
         restartCaseTest.replay();
     }
 
-    @Test
+    @RetryingTest(5)
     @LoadFlows({"flows/valids/failed-first.yaml"})
     void restartMultiple() throws Exception {
         restartCaseTest.restartMultiple();
     }
 
-    @Test
+    @RetryingTest(5) // Flaky on CI but never locally even with 100 repetitions
     @LoadFlows({"flows/valids/restart_always_failed.yaml"})
     void restartFailedThenFailureWithGlobalErrors() throws Exception {
         restartCaseTest.restartFailedThenFailureWithGlobalErrors();
     }
 
-    @Test
+    @RetryingTest(5)
     @LoadFlows({"flows/valids/restart_local_errors.yaml"})
-    protected void restartFailedThenFailureWithLocalErrors() throws Exception {
+    void restartFailedThenFailureWithLocalErrors() throws Exception {
         restartCaseTest.restartFailedThenFailureWithLocalErrors();
     }
 
@@ -195,27 +199,29 @@ public abstract class AbstractRunnerTest {
         restartCaseTest.restartFailedWithAfterExecution();
     }
 
-    @Test
-    @LoadFlows(value = {"flows/valids/trigger-flow-listener-no-inputs.yaml",
+    @RetryingTest(5)
+    @LoadFlows({"flows/valids/trigger-flow-listener-no-inputs.yaml",
         "flows/valids/trigger-flow-listener.yaml",
         "flows/valids/trigger-flow-listener-namespace-condition.yaml",
-        "flows/valids/trigger-flow.yaml"}, tenantId = "listener-tenant")
+        "flows/valids/trigger-flow.yaml"})
     void flowTrigger() throws Exception {
-        flowTriggerCaseTest.trigger("listener-tenant");
+        flowTriggerCaseTest.trigger();
     }
 
-    @Test // flaky on CI but never fail locally
+    @RetryingTest(5) // flaky on CI but never fail locally
     @LoadFlows({"flows/valids/trigger-flow-listener-with-pause.yaml",
         "flows/valids/trigger-flow-with-pause.yaml"})
     void flowTriggerWithPause() throws Exception {
         flowTriggerCaseTest.triggerWithPause();
     }
 
+    @FlakyTest
+    @Disabled
     @Test
-    @LoadFlows(value = {"flows/valids/trigger-flow-listener-with-concurrency-limit.yaml",
-        "flows/valids/trigger-flow-with-concurrency-limit.yaml"}, tenantId = "trigger-tenant")
+    @LoadFlows({"flows/valids/trigger-flow-listener-with-concurrency-limit.yaml",
+        "flows/valids/trigger-flow-with-concurrency-limit.yaml"})
     void flowTriggerWithConcurrencyLimit() throws Exception {
-        flowTriggerCaseTest.triggerWithConcurrencyLimit("trigger-tenant");
+        flowTriggerCaseTest.triggerWithConcurrencyLimit();
     }
 
     @Test
@@ -226,12 +232,12 @@ public abstract class AbstractRunnerTest {
         multipleConditionTriggerCaseTest.trigger();
     }
 
-    @Test // Flaky on CI but never locally even with 100 repetitions
-    @LoadFlows(value = {"flows/valids/trigger-flow-listener-namespace-condition.yaml",
+    @RetryingTest(5) // Flaky on CI but never locally even with 100 repetitions
+    @LoadFlows({"flows/valids/trigger-flow-listener-namespace-condition.yaml",
         "flows/valids/trigger-multiplecondition-flow-c.yaml",
-        "flows/valids/trigger-multiplecondition-flow-d.yaml"}, tenantId = "condition-tenant")
+        "flows/valids/trigger-multiplecondition-flow-d.yaml"})
     void multipleConditionTriggerFailed() throws Exception {
-        multipleConditionTriggerCaseTest.failed("condition-tenant");
+        multipleConditionTriggerCaseTest.failed();
     }
 
     @Test
@@ -242,13 +248,12 @@ public abstract class AbstractRunnerTest {
         multipleConditionTriggerCaseTest.flowTriggerPreconditions();
     }
 
-    @Disabled
     @Test
-    @LoadFlows(value = {"flows/valids/flow-trigger-preconditions-flow-listen.yaml",
+    @LoadFlows({"flows/valids/flow-trigger-preconditions-flow-listen.yaml",
         "flows/valids/flow-trigger-preconditions-flow-a.yaml",
-        "flows/valids/flow-trigger-preconditions-flow-b.yaml"}, tenantId = TENANT_1)
+        "flows/valids/flow-trigger-preconditions-flow-b.yaml"})
     void flowTriggerPreconditionsMergeOutputs() throws Exception {
-        multipleConditionTriggerCaseTest.flowTriggerPreconditionsMergeOutputs(TENANT_1);
+        multipleConditionTriggerCaseTest.flowTriggerPreconditionsMergeOutputs();
     }
 
     @Test
@@ -257,7 +262,7 @@ public abstract class AbstractRunnerTest {
         multipleConditionTriggerCaseTest.flowTriggerOnPaused();
     }
 
-    @Test
+    @RetryingTest(5)
     @LoadFlows({"flows/valids/each-null.yaml"})
     void eachWithNull() throws Exception {
         EachSequentialTest.eachNullTest(runnerUtils, logsQueue);
@@ -269,7 +274,7 @@ public abstract class AbstractRunnerTest {
         pluginDefaultsCaseTest.taskDefaults();
     }
 
-    @Test
+    @RetryingTest(5)
     @LoadFlows({"flows/valids/switch.yaml",
         "flows/valids/task-flow.yaml",
         "flows/valids/task-flow-inherited-labels.yaml"})
@@ -278,19 +283,19 @@ public abstract class AbstractRunnerTest {
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/switch.yaml",
+    @LoadFlows({"flows/valids/switch.yaml",
         "flows/valids/task-flow.yaml",
-        "flows/valids/task-flow-inherited-labels.yaml"}, tenantId = TENANT_1)
+        "flows/valids/task-flow-inherited-labels.yaml"})
     void flowWaitFailed() throws Exception {
-        flowCaseTest.waitFailed(TENANT_1);
+        flowCaseTest.waitFailed();
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/switch.yaml",
+    @LoadFlows({"flows/valids/switch.yaml",
         "flows/valids/task-flow.yaml",
-        "flows/valids/task-flow-inherited-labels.yaml"}, tenantId = TENANT_2)
+        "flows/valids/task-flow-inherited-labels.yaml"})
     public void invalidOutputs() throws Exception {
-        flowCaseTest.invalidOutputs(TENANT_2);
+        flowCaseTest.invalidOutputs();
     }
 
     @Test
@@ -300,9 +305,9 @@ public abstract class AbstractRunnerTest {
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/working-directory.yaml"}, tenantId = TENANT_1)
+    @LoadFlows({"flows/valids/working-directory.yaml"})
     public void workerFailed() throws Exception {
-        workingDirectoryTest.failed(TENANT_1, runnerUtils);
+        workingDirectoryTest.failed(runnerUtils);
     }
 
     @Test
@@ -317,7 +322,7 @@ public abstract class AbstractRunnerTest {
         workingDirectoryTest.cache(runnerUtils);
     }
 
-    @Test // flaky on MySQL
+    @RetryingTest(5) // flaky on MySQL
     @LoadFlows({"flows/valids/pause-test.yaml"})
     public void pauseRun() throws Exception {
         pauseTest.run(runnerUtils);
@@ -353,44 +358,44 @@ public abstract class AbstractRunnerTest {
         skipExecutionCaseTest.skipExecution();
     }
 
-    @Test
+    @RetryingTest(5)
     @LoadFlows({"flows/valids/for-each-item-subflow.yaml",
         "flows/valids/for-each-item.yaml"})
     protected void forEachItem() throws Exception {
         forEachItemCaseTest.forEachItem();
     }
 
-    @Test
-    @LoadFlows(value = {"flows/valids/for-each-item.yaml"}, tenantId = TENANT_1)
+    @RetryingTest(5)
+    @LoadFlows({"flows/valids/for-each-item.yaml"})
     protected void forEachItemEmptyItems() throws Exception {
-        forEachItemCaseTest.forEachItemEmptyItems(TENANT_1);
+        forEachItemCaseTest.forEachItemEmptyItems();
     }
 
-    @Test
+    @RetryingTest(5)
     @LoadFlows({"flows/valids/for-each-item-subflow-failed.yaml",
         "flows/valids/for-each-item-failed.yaml"})
     protected void forEachItemFailed() throws Exception {
         forEachItemCaseTest.forEachItemFailed();
     }
 
-    @Test
+    @RetryingTest(5)
     @LoadFlows({"flows/valids/for-each-item-outputs-subflow.yaml",
         "flows/valids/for-each-item-outputs.yaml"})
     protected void forEachItemSubflowOutputs() throws Exception {
         forEachItemCaseTest.forEachItemWithSubflowOutputs();
     }
 
-    @Test // flaky on CI but always pass locally even with 100 iterations
-    @LoadFlows(value = {"flows/valids/restart-for-each-item.yaml", "flows/valids/restart-child.yaml"}, tenantId = TENANT_1)
+    @RetryingTest(5) // flaky on CI but always pass locally even with 100 iterations
+    @LoadFlows({"flows/valids/restart-for-each-item.yaml", "flows/valids/restart-child.yaml"})
     void restartForEachItem() throws Exception {
-        forEachItemCaseTest.restartForEachItem(TENANT_1);
+        forEachItemCaseTest.restartForEachItem();
     }
 
-    @Test
-    @LoadFlows(value = {"flows/valids/for-each-item-subflow.yaml",
-        "flows/valids/for-each-item-in-if.yaml"}, tenantId = TENANT_1)
+    @RetryingTest(5)
+    @LoadFlows({"flows/valids/for-each-item-subflow.yaml",
+        "flows/valids/for-each-item-in-if.yaml"})
     protected void forEachItemInIf() throws Exception {
-        forEachItemCaseTest.forEachItemInIf(TENANT_1);
+        forEachItemCaseTest.forEachItemInIf();
     }
 
     @Test
@@ -431,9 +436,9 @@ public abstract class AbstractRunnerTest {
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/flow-concurrency-for-each-item.yaml", "flows/valids/flow-concurrency-queue.yml"}, tenantId = TENANT_1)
+    @LoadFlows({"flows/valids/flow-concurrency-for-each-item.yaml", "flows/valids/flow-concurrency-queue.yml"})
     protected void flowConcurrencyWithForEachItem() throws Exception {
-        flowConcurrencyCaseTest.flowConcurrencyWithForEachItem(TENANT_1);
+        flowConcurrencyCaseTest.flowConcurrencyWithForEachItem();
     }
 
     @Test
@@ -449,9 +454,9 @@ public abstract class AbstractRunnerTest {
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/flow-concurrency-subflow.yml", "flows/valids/flow-concurrency-cancel.yml"}, tenantId = TENANT_1)
+    @LoadFlows({"flows/valids/flow-concurrency-subflow.yml", "flows/valids/flow-concurrency-cancel.yml"})
     void flowConcurrencySubflow() throws Exception {
-        flowConcurrencyCaseTest.flowConcurrencySubflow(TENANT_1);
+        flowConcurrencyCaseTest.flowConcurrencySubflow();
     }
 
     @Test
@@ -506,9 +511,9 @@ public abstract class AbstractRunnerTest {
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/minimal.yaml"}, tenantId = TENANT_1)
+    @LoadFlows({"flows/valids/minimal.yaml"})
     void shouldScheduleOnDate() throws Exception {
-        scheduleDateCaseTest.shouldScheduleOnDate(TENANT_1);
+        scheduleDateCaseTest.shouldScheduleOnDate();
     }
 
     @Test
@@ -530,15 +535,15 @@ public abstract class AbstractRunnerTest {
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/sla-execution-condition.yaml"}, tenantId = TENANT_1)
+    @LoadFlows({"flows/valids/sla-execution-condition.yaml"})
     void executionConditionSLAShouldCancel() throws Exception {
-        slaTestCase.executionConditionSLAShouldCancel(TENANT_1);
+        slaTestCase.executionConditionSLAShouldCancel();
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/sla-execution-condition.yaml"}, tenantId = TENANT_2)
+    @LoadFlows({"flows/valids/sla-execution-condition.yaml"})
     void executionConditionSLAShouldLabel() throws Exception {
-        slaTestCase.executionConditionSLAShouldLabel(TENANT_2);
+        slaTestCase.executionConditionSLAShouldLabel();
     }
 
     @Test
@@ -558,15 +563,15 @@ public abstract class AbstractRunnerTest {
     }
 
     @Test
-    @ExecuteFlow(value = "flows/valids/failed-first.yaml", tenantId = TENANT_1)
+    @ExecuteFlow("flows/valids/failed-first.yaml")
     public void changeStateShouldEndsInSuccess(Execution execution) throws Exception {
         changeStateTestCase.changeStateShouldEndsInSuccess(execution);
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/failed-first.yaml", "flows/valids/subflow-parent-of-failed.yaml"}, tenantId = TENANT_2)
+    @LoadFlows({"flows/valids/failed-first.yaml", "flows/valids/subflow-parent-of-failed.yaml"})
     public void changeStateInSubflowShouldEndsParentFlowInSuccess() throws Exception {
-        changeStateTestCase.changeStateInSubflowShouldEndsParentFlowInSuccess(TENANT_2);
+        changeStateTestCase.changeStateInSubflowShouldEndsParentFlowInSuccess();
     }
 
     @Test

core/src/test/java/io/kestra/core/runners/ChangeStateTestCase.java

@@ -3,18 +3,25 @@ package io.kestra.core.runners;
 import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.flows.Flow;
 import io.kestra.core.models.flows.State;
-import io.kestra.core.models.flows.State.Type;
+import io.kestra.core.queues.QueueFactoryInterface;
+import io.kestra.core.queues.QueueInterface;
 import io.kestra.core.repositories.FlowRepositoryInterface;
 import io.kestra.core.services.ExecutionService;
+import io.kestra.core.utils.TestsUtils;
 import jakarta.inject.Inject;
+import jakarta.inject.Named;
 import jakarta.inject.Singleton;
+import reactor.core.publisher.Flux;
 
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static org.assertj.core.api.Assertions.assertThat;
 
 @Singleton
 public class ChangeStateTestCase {
-
-    public static final String NAMESPACE = "io.kestra.tests";
     @Inject
     private FlowRepositoryInterface flowRepository;
 
@@ -22,7 +29,11 @@ public class ChangeStateTestCase {
     private ExecutionService executionService;
 
     @Inject
-    private TestRunnerUtils runnerUtils;
+    @Named(QueueFactoryInterface.EXECUTION_NAMED)
+    private QueueInterface<Execution> executionQueue;
+
+    @Inject
+    private RunnerUtils runnerUtils;
 
     public void changeStateShouldEndsInSuccess(Execution execution) throws Exception {
         assertThat(execution.getState().getCurrent()).isEqualTo(State.Type.FAILED);
@@ -30,40 +41,73 @@ public class ChangeStateTestCase {
         assertThat(execution.getTaskRunList().getFirst().getState().getCurrent()).isEqualTo(State.Type.FAILED);
 
         // await for the last execution
+        CountDownLatch latch = new CountDownLatch(1);
+        AtomicReference<Execution> lastExecution = new AtomicReference<>();
+        Flux<Execution> receivedExecutions = TestsUtils.receive(executionQueue, either -> {
+            Execution exec = either.getLeft();
+            if (execution.getId().equals(exec.getId()) && exec.getState().getCurrent() == State.Type.SUCCESS) {
+                lastExecution.set(exec);
+                latch.countDown();
+            }
+        });
+
         Flow flow = flowRepository.findByExecution(execution);
         Execution markedAs = executionService.markAs(execution, flow, execution.getTaskRunList().getFirst().getId(), State.Type.SUCCESS);
-        Execution lastExecution = runnerUtils.emitAndAwaitExecution(e -> e.getState().getCurrent().equals(Type.SUCCESS), markedAs);
+        executionQueue.emit(markedAs);
 
-        assertThat(lastExecution.getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
-        assertThat(lastExecution.getTaskRunList()).hasSize(2);
-        assertThat(lastExecution.getTaskRunList().getFirst().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
+        assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
+        receivedExecutions.blockLast();
+        assertThat(lastExecution.get().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
+        assertThat(lastExecution.get().getTaskRunList()).hasSize(2);
+        assertThat(lastExecution.get().getTaskRunList().getFirst().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
     }
 
-    public void changeStateInSubflowShouldEndsParentFlowInSuccess(String tenantId) throws Exception {
+    public void changeStateInSubflowShouldEndsParentFlowInSuccess() throws Exception {
+        // await for the subflow execution
+        CountDownLatch latch = new CountDownLatch(1);
+        AtomicReference<Execution> lastExecution = new AtomicReference<>();
+        Flux<Execution> receivedExecutions = TestsUtils.receive(executionQueue, either -> {
+            Execution exec = either.getLeft();
+            if ("failed-first".equals(exec.getFlowId()) && exec.getState().getCurrent() == State.Type.FAILED) {
+                lastExecution.set(exec);
+                latch.countDown();
+            }
+        });
+
         // run the parent flow
-        Execution execution = runnerUtils.runOne(tenantId, NAMESPACE, "subflow-parent-of-failed");
+        Execution execution = runnerUtils.runOne(MAIN_TENANT, "io.kestra.tests", "subflow-parent-of-failed");
         assertThat(execution.getState().getCurrent()).isEqualTo(State.Type.FAILED);
         assertThat(execution.getTaskRunList()).hasSize(1);
         assertThat(execution.getTaskRunList().getFirst().getState().getCurrent()).isEqualTo(State.Type.FAILED);
 
         // assert on the subflow
-        Execution lastExecution = runnerUtils.awaitFlowExecution(e -> e.getState().getCurrent().equals(Type.FAILED), tenantId, NAMESPACE, "failed-first");
-        assertThat(lastExecution.getState().getCurrent()).isEqualTo(State.Type.FAILED);
-        assertThat(lastExecution.getTaskRunList()).hasSize(1);
-        assertThat(lastExecution.getTaskRunList().getFirst().getState().getCurrent()).isEqualTo(State.Type.FAILED);
+        assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
+        receivedExecutions.blockLast();
+        assertThat(lastExecution.get().getState().getCurrent()).isEqualTo(State.Type.FAILED);
+        assertThat(lastExecution.get().getTaskRunList()).hasSize(1);
+        assertThat(lastExecution.get().getTaskRunList().getFirst().getState().getCurrent()).isEqualTo(State.Type.FAILED);
+
+        // await for the parent execution
+        CountDownLatch parentLatch = new CountDownLatch(1);
+        AtomicReference<Execution> lastParentExecution = new AtomicReference<>();
+        receivedExecutions = TestsUtils.receive(executionQueue, either -> {
+            Execution exec = either.getLeft();
+            if (execution.getId().equals(exec.getId()) && exec.getState().isTerminated()) {
+                lastParentExecution.set(exec);
+                parentLatch.countDown();
+            }
+        });
 
         // restart the subflow
-        Flow flow = flowRepository.findByExecution(lastExecution);
-        Execution markedAs = executionService.markAs(lastExecution, flow, lastExecution.getTaskRunList().getFirst().getId(), State.Type.SUCCESS);
-        runnerUtils.emitAndAwaitExecution(e -> e.getState().isTerminated(), markedAs);
-
-        //We wait for the subflow execution to pass from failed to success
-        Execution lastParentExecution = runnerUtils.awaitFlowExecution(e ->
-            e.getTaskRunList().getFirst().getState().getCurrent().equals(Type.SUCCESS), tenantId, NAMESPACE, "subflow-parent-of-failed");
+        Flow flow = flowRepository.findByExecution(lastExecution.get());
+        Execution markedAs = executionService.markAs(lastExecution.get(), flow, lastExecution.get().getTaskRunList().getFirst().getId(), State.Type.SUCCESS);
+        executionQueue.emit(markedAs);
 
         // assert for the parent flow
-        assertThat(lastParentExecution.getState().getCurrent()).isEqualTo(State.Type.FAILED); // FIXME should be success but it's FAILED on unit tests
-        assertThat(lastParentExecution.getTaskRunList()).hasSize(1);
-        assertThat(lastParentExecution.getTaskRunList().getFirst().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
+        assertThat(parentLatch.await(10, TimeUnit.SECONDS)).isTrue();
+        receivedExecutions.blockLast();
+        assertThat(lastParentExecution.get().getState().getCurrent()).isEqualTo(State.Type.FAILED); // FIXME should be success but it's FAILED on unit tests
+        assertThat(lastParentExecution.get().getTaskRunList()).hasSize(1);
+        assertThat(lastParentExecution.get().getTaskRunList().getFirst().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
     }
 }

core/src/test/java/io/kestra/core/runners/CustomVariableRendererTest.java

@@ -0,0 +1,58 @@
+package io.kestra.core.runners;
+
+import io.kestra.core.exceptions.IllegalVariableEvaluationException;
+import io.kestra.core.junit.annotations.KestraTest;
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.context.annotation.Factory;
+import io.micronaut.context.annotation.Primary;
+import io.micronaut.context.annotation.Requires;
+import io.micronaut.test.annotation.MockBean;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
+import org.junit.jupiter.api.Test;
+
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@KestraTest
+class CustomVariableRendererTest {
+    
+    @Inject
+    private SecureVariableRendererFactory secureVariableRendererFactory;
+    
+    @Inject
+    private VariableRenderer renderer;
+    
+    @Test
+    void shouldUseCustomVariableRender() throws IllegalVariableEvaluationException {
+        // When
+        String result = renderer.render("{{ dummy }}", Map.of());
+        
+        // Then
+        assertThat(result).isEqualTo("alternativeRender");
+    }
+    
+    @Test
+    void shouldUseCustomVariableRenderWhenUsingSecured() throws IllegalVariableEvaluationException {
+        // Given
+        VariableRenderer renderer = secureVariableRendererFactory.createOrGet();
+        
+        // When
+        String result = renderer.render("{{ dummy }}", Map.of());
+        
+        // Then
+        assertThat(result).isEqualTo("alternativeRender");
+    }
+    
+    @MockBean(VariableRenderer.class)
+    VariableRenderer testCustomRenderer(ApplicationContext applicationContext) {
+        return new VariableRenderer(applicationContext, null) {
+            
+            @Override
+            protected String alternativeRender(Exception e, String inline, Map<String, Object> variables) {
+                return "alternativeRender";
+            }
+        };
+    }
+}

core/src/test/java/io/kestra/core/runners/EmptyVariablesTest.java

@@ -18,7 +18,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 public class EmptyVariablesTest {
 
     @Inject
-    private TestRunnerUtils runnerUtils;
+    private RunnerUtils runnerUtils;
     @Inject
     private FlowInputOutput flowIO;
 

core/src/test/java/io/kestra/core/runners/ExecutionServiceTest.java

@@ -20,7 +20,6 @@ import io.kestra.plugin.core.debug.Return;
 import io.kestra.plugin.core.flow.Pause;
 import jakarta.inject.Inject;
 import lombok.extern.slf4j.Slf4j;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junitpioneer.jupiter.RetryingTest;
 import org.slf4j.event.Level;
@@ -41,10 +40,6 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
 @Slf4j
 @KestraTest(startRunner = true)
 class ExecutionServiceTest {
-
-    public static final String TENANT_1 = "tenant1";
-    public static final String TENANT_2 = "tenant2";
-    public static final String TENANT_3 = "tenant3";
     @Inject
     ExecutionService executionService;
 
@@ -58,7 +53,7 @@ class ExecutionServiceTest {
     LogRepositoryInterface logRepository;
 
     @Inject
-    TestRunnerUtils runnerUtils;
+    RunnerUtils runnerUtils;
 
     @Test
     @LoadFlows({"flows/valids/restart_last_failed.yaml"})
@@ -80,13 +75,13 @@ class ExecutionServiceTest {
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/restart_last_failed.yaml"}, tenantId = TENANT_1)
+    @LoadFlows({"flows/valids/restart_last_failed.yaml"})
     void restartSimpleRevision() throws Exception {
-        Execution execution = runnerUtils.runOne(TENANT_1, "io.kestra.tests", "restart_last_failed");
+        Execution execution = runnerUtils.runOne(MAIN_TENANT, "io.kestra.tests", "restart_last_failed");
         assertThat(execution.getTaskRunList()).hasSize(3);
         assertThat(execution.getState().getCurrent()).isEqualTo(State.Type.FAILED);
 
-        FlowWithSource flow = flowRepository.findByIdWithSource(TENANT_1, "io.kestra.tests", "restart_last_failed").orElseThrow();
+        FlowWithSource flow = flowRepository.findByIdWithSource(MAIN_TENANT, "io.kestra.tests", "restart_last_failed").orElseThrow();
         flowRepository.update(
             GenericFlow.of(flow),
             flow.updateTask(
@@ -129,9 +124,9 @@ class ExecutionServiceTest {
     }
 
     @RetryingTest(5)
-    @LoadFlows(value = {"flows/valids/restart-each.yaml"}, tenantId = TENANT_1)
+    @LoadFlows({"flows/valids/restart-each.yaml"})
     void restartFlowable2() throws Exception {
-        Execution execution = runnerUtils.runOne(TENANT_1, "io.kestra.tests", "restart-each", null, (f, e) -> ImmutableMap.of("failed", "SECOND"));
+        Execution execution = runnerUtils.runOne(MAIN_TENANT, "io.kestra.tests", "restart-each", null, (f, e) -> ImmutableMap.of("failed", "SECOND"));
         assertThat(execution.getState().getCurrent()).isEqualTo(State.Type.FAILED);
 
         Execution restart = executionService.restart(execution, null);
@@ -182,9 +177,9 @@ class ExecutionServiceTest {
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/logs.yaml"}, tenantId = TENANT_1)
+    @LoadFlows({"flows/valids/logs.yaml"})
     void replaySimple() throws Exception {
-        Execution execution = runnerUtils.runOne(TENANT_1, "io.kestra.tests", "logs");
+        Execution execution = runnerUtils.runOne(MAIN_TENANT, "io.kestra.tests", "logs");
         assertThat(execution.getTaskRunList()).hasSize(5);
         assertThat(execution.getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
 
@@ -201,9 +196,9 @@ class ExecutionServiceTest {
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/restart-each.yaml"}, tenantId = TENANT_2)
+    @LoadFlows({"flows/valids/restart-each.yaml"})
     void replayFlowable() throws Exception {
-        Execution execution = runnerUtils.runOne(TENANT_2, "io.kestra.tests", "restart-each", null, (f, e) -> ImmutableMap.of("failed", "NO"));
+        Execution execution = runnerUtils.runOne(MAIN_TENANT, "io.kestra.tests", "restart-each", null, (f, e) -> ImmutableMap.of("failed", "NO"));
         assertThat(execution.getTaskRunList()).hasSize(20);
         assertThat(execution.getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
 
@@ -218,7 +213,6 @@ class ExecutionServiceTest {
         assertThat(restart.getLabels()).contains(new Label(Label.REPLAY, "true"));
     }
 
-    @Disabled
     @Test
     @LoadFlows({"flows/valids/parallel-nested.yaml"})
     void replayParallel() throws Exception {
@@ -240,7 +234,7 @@ class ExecutionServiceTest {
     }
 
     @Test
-    @ExecuteFlow(value = "flows/valids/each-sequential-nested.yaml", tenantId = TENANT_2)
+    @ExecuteFlow("flows/valids/each-sequential-nested.yaml")
     void replayEachSeq(Execution execution) throws Exception {
         assertThat(execution.getTaskRunList()).hasSize(23);
         assertThat(execution.getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
@@ -259,7 +253,7 @@ class ExecutionServiceTest {
     }
 
     @Test
-    @ExecuteFlow(value = "flows/valids/each-sequential-nested.yaml", tenantId = TENANT_1)
+    @ExecuteFlow("flows/valids/each-sequential-nested.yaml")
     void replayEachSeq2(Execution execution) throws Exception {
         assertThat(execution.getTaskRunList()).hasSize(23);
         assertThat(execution.getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
@@ -318,9 +312,9 @@ class ExecutionServiceTest {
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/each-parallel-nested.yaml"}, tenantId = TENANT_1)
+    @LoadFlows({"flows/valids/each-parallel-nested.yaml"})
     void markAsEachPara() throws Exception {
-        Execution execution = runnerUtils.runOne(TENANT_1, "io.kestra.tests", "each-parallel-nested");
+        Execution execution = runnerUtils.runOne(MAIN_TENANT, "io.kestra.tests", "each-parallel-nested");
         Flow flow = flowRepository.findByExecution(execution);
 
         assertThat(execution.getTaskRunList()).hasSize(11);
@@ -370,9 +364,9 @@ class ExecutionServiceTest {
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/pause-test.yaml"}, tenantId = TENANT_1)
+    @LoadFlows({"flows/valids/pause-test.yaml"})
     void resumePausedToKilling() throws Exception {
-        Execution execution = runnerUtils.runOneUntilPaused(TENANT_1, "io.kestra.tests", "pause-test");
+        Execution execution = runnerUtils.runOneUntilPaused(MAIN_TENANT, "io.kestra.tests", "pause-test");
         Flow flow = flowRepository.findByExecution(execution);
 
         assertThat(execution.getTaskRunList()).hasSize(1);
@@ -385,7 +379,7 @@ class ExecutionServiceTest {
     }
 
     @Test
-    @ExecuteFlow(value = "flows/valids/logs.yaml", tenantId = TENANT_2)
+    @ExecuteFlow("flows/valids/logs.yaml")
     void deleteExecution(Execution execution) throws IOException, TimeoutException {
         assertThat(execution.getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
         Await.until(() -> logRepository.findByExecutionId(execution.getTenantId(), execution.getId(), Level.TRACE).size() == 5, Duration.ofMillis(10), Duration.ofSeconds(5));
@@ -397,7 +391,7 @@ class ExecutionServiceTest {
     }
 
     @Test
-    @ExecuteFlow(value = "flows/valids/logs.yaml", tenantId = TENANT_3)
+    @ExecuteFlow("flows/valids/logs.yaml")
     void deleteExecutionKeepLogs(Execution execution) throws IOException, TimeoutException {
         assertThat(execution.getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
         Await.until(() -> logRepository.findByExecutionId(execution.getTenantId(), execution.getId(), Level.TRACE).size() == 5, Duration.ofMillis(10), Duration.ofSeconds(5));
@@ -437,9 +431,9 @@ class ExecutionServiceTest {
     }
 
     @Test
-    @LoadFlows(value = {"flows/valids/pause_no_tasks.yaml"}, tenantId = TENANT_1)
+    @LoadFlows({"flows/valids/pause_no_tasks.yaml"})
     void killToState() throws Exception {
-        Execution execution = runnerUtils.runOneUntilPaused(TENANT_1, "io.kestra.tests", "pause_no_tasks");
+        Execution execution = runnerUtils.runOneUntilPaused(MAIN_TENANT, "io.kestra.tests", "pause_no_tasks");
         Flow flow = flowRepository.findByExecution(execution);
 
         Execution killed = executionService.kill(execution, flow, Optional.of(State.Type.CANCELLED));

core/src/test/java/io/kestra/core/runners/FilesServiceTest.java

@@ -18,14 +18,11 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.List;
 import java.util.Map;
-import org.junit.jupiter.api.parallel.Execution;
-import org.junit.jupiter.api.parallel.ExecutionMode;
 
 import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static org.assertj.core.api.Assertions.assertThat;
 
 @KestraTest(rebuildContext = true)
-@Execution(ExecutionMode.SAME_THREAD)
 class FilesServiceTest {
     @Inject
     private TestRunContextFactory runContextFactory;

core/src/test/java/io/kestra/core/runners/FlowConcurrencyCaseTest.java

@@ -1,17 +1,24 @@
 package io.kestra.core.runners;
 
 import io.kestra.core.models.executions.Execution;
+import io.kestra.core.models.executions.ExecutionKilled;
+import io.kestra.core.models.executions.ExecutionKilledExecution;
 import io.kestra.core.models.flows.Flow;
 import io.kestra.core.models.flows.State;
-import io.kestra.core.models.flows.State.History;
 import io.kestra.core.models.flows.State.Type;
 import io.kestra.core.queues.QueueException;
+import io.kestra.core.queues.QueueFactoryInterface;
+import io.kestra.core.queues.QueueInterface;
+import io.kestra.core.reporter.model.Count;
 import io.kestra.core.repositories.FlowRepositoryInterface;
 import io.kestra.core.services.ExecutionService;
 import io.kestra.core.storages.StorageInterface;
+import io.kestra.core.utils.TestsUtils;
 import jakarta.inject.Inject;
+import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import org.apache.commons.lang3.StringUtils;
+import reactor.core.publisher.Flux;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -21,21 +28,24 @@ import java.net.URISyntaxException;
 import java.nio.file.Files;
 import java.time.Duration;
 import java.util.*;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.IntStream;
 
 import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 @Singleton
 public class FlowConcurrencyCaseTest {
-
-    public static final String NAMESPACE = "io.kestra.tests";
     @Inject
     private StorageInterface storageInterface;
 
     @Inject
-    protected TestRunnerUtils runnerUtils;
+    protected RunnerUtils runnerUtils;
 
     @Inject
     private FlowInputOutput flowIO;
@@ -43,168 +53,404 @@ public class FlowConcurrencyCaseTest {
     @Inject
     private FlowRepositoryInterface flowRepository;
 
+    @Inject
+    @Named(QueueFactoryInterface.EXECUTION_NAMED)
+    protected QueueInterface<Execution> executionQueue;
+
     @Inject
     private ExecutionService executionService;
 
-    public void flowConcurrencyCancel() throws TimeoutException, QueueException {
-        Execution execution1 = runnerUtils.runOneUntilRunning(MAIN_TENANT, NAMESPACE, "flow-concurrency-cancel", null, null, Duration.ofSeconds(30));
-        Execution execution2 = runnerUtils.runOne(MAIN_TENANT, NAMESPACE, "flow-concurrency-cancel");
+    @Inject
+    @Named(QueueFactoryInterface.KILL_NAMED)
+    protected QueueInterface<ExecutionKilled> killQueue;
+
+    public void flowConcurrencyCancel() throws TimeoutException, QueueException, InterruptedException {
+        Execution execution1 = runnerUtils.runOneUntilRunning(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-cancel", null, null, Duration.ofSeconds(30));
+        Execution execution2 = runnerUtils.runOne(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-cancel");
 
         assertThat(execution1.getState().isRunning()).isTrue();
         assertThat(execution2.getState().getCurrent()).isEqualTo(State.Type.CANCELLED);
 
-        runnerUtils.awaitExecution(e -> e.getState().getCurrent().equals(Type.SUCCESS), execution1);
+        CountDownLatch latch1 = new CountDownLatch(1);
+
+        Flux<Execution> receive = TestsUtils.receive(executionQueue, e -> {
+            if (e.getLeft().getId().equals(execution1.getId())) {
+                if (e.getLeft().getState().getCurrent() == State.Type.SUCCESS) {
+                    latch1.countDown();
+                }
+            }
+
+            // FIXME we should fail if we receive the cancel execution again but on Kafka it happens
+        });
+
+        assertTrue(latch1.await(1, TimeUnit.MINUTES));
+        receive.blockLast();
     }
 
-    public void flowConcurrencyFail() throws TimeoutException, QueueException {
-        Execution execution1 = runnerUtils.runOneUntilRunning(MAIN_TENANT, NAMESPACE, "flow-concurrency-fail", null, null, Duration.ofSeconds(30));
-        Execution execution2 = runnerUtils.runOne(MAIN_TENANT, NAMESPACE, "flow-concurrency-fail");
+    public void flowConcurrencyFail() throws TimeoutException, QueueException, InterruptedException {
+        Execution execution1 = runnerUtils.runOneUntilRunning(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-fail", null, null, Duration.ofSeconds(30));
+        Execution execution2 = runnerUtils.runOne(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-fail");
 
         assertThat(execution1.getState().isRunning()).isTrue();
         assertThat(execution2.getState().getCurrent()).isEqualTo(State.Type.FAILED);
 
-        runnerUtils.awaitExecution(e -> e.getState().getCurrent().equals(Type.SUCCESS), execution1);
+        CountDownLatch latch1 = new CountDownLatch(1);
+
+        Flux<Execution> receive = TestsUtils.receive(executionQueue, e -> {
+            if (e.getLeft().getId().equals(execution1.getId())) {
+                if (e.getLeft().getState().getCurrent() == State.Type.SUCCESS) {
+                    latch1.countDown();
+                }
+            }
+
+            // FIXME we should fail if we receive the cancel execution again but on Kafka it happens
+        });
+
+        assertTrue(latch1.await(1, TimeUnit.MINUTES));
+        receive.blockLast();
     }
 
-    public void flowConcurrencyQueue() throws QueueException {
-        Execution execution1 = runnerUtils.runOneUntilRunning(MAIN_TENANT, NAMESPACE, "flow-concurrency-queue", null, null, Duration.ofSeconds(30));
+    public void flowConcurrencyQueue() throws TimeoutException, QueueException, InterruptedException {
+        Execution execution1 = runnerUtils.runOneUntilRunning(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-queue", null, null, Duration.ofSeconds(30));
         Flow flow = flowRepository
-            .findById(MAIN_TENANT, NAMESPACE, "flow-concurrency-queue", Optional.empty())
+            .findById(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-queue", Optional.empty())
             .orElseThrow();
         Execution execution2 = Execution.newExecution(flow, null, null, Optional.empty());
-        Execution executionResult2 = runnerUtils.emitAndAwaitExecution(e -> e.getState().getCurrent().equals(Type.SUCCESS), execution2);
-        Execution executionResult1 = runnerUtils.awaitExecution(e -> e.getState().getCurrent().equals(Type.SUCCESS), execution1);
+        executionQueue.emit(execution2);
 
         assertThat(execution1.getState().isRunning()).isTrue();
         assertThat(execution2.getState().getCurrent()).isEqualTo(State.Type.CREATED);
 
-        assertThat(executionResult1.getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
-        assertThat(executionResult2.getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
-        assertThat(executionResult2.getState().getHistories().getFirst().getState()).isEqualTo(State.Type.CREATED);
-        assertThat(executionResult2.getState().getHistories().get(1).getState()).isEqualTo(State.Type.QUEUED);
-        assertThat(executionResult2.getState().getHistories().get(2).getState()).isEqualTo(State.Type.RUNNING);
+        var executionResult1  = new AtomicReference<Execution>();
+        var executionResult2  = new AtomicReference<Execution>();
+
+        CountDownLatch latch1 = new CountDownLatch(1);
+        CountDownLatch latch2 = new CountDownLatch(1);
+        CountDownLatch latch3 = new CountDownLatch(1);
+
+        Flux<Execution> receive = TestsUtils.receive(executionQueue, e -> {
+            if (e.getLeft().getId().equals(execution1.getId())) {
+                executionResult1.set(e.getLeft());
+                if (e.getLeft().getState().getCurrent() == State.Type.SUCCESS) {
+                    latch1.countDown();
+                }
+            }
+
+            if (e.getLeft().getId().equals(execution2.getId())) {
+                executionResult2.set(e.getLeft());
+                if (e.getLeft().getState().getCurrent() == State.Type.RUNNING) {
+                    latch2.countDown();
+                }
+                if (e.getLeft().getState().getCurrent() == State.Type.SUCCESS) {
+                    latch3.countDown();
+                }
+            }
+        });
+
+        assertTrue(latch1.await(1, TimeUnit.MINUTES));
+        assertTrue(latch2.await(1, TimeUnit.MINUTES));
+        assertTrue(latch3.await(1, TimeUnit.MINUTES));
+        receive.blockLast();
+
+        assertThat(executionResult1.get().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
+        assertThat(executionResult2.get().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
+        assertThat(executionResult2.get().getState().getHistories().getFirst().getState()).isEqualTo(State.Type.CREATED);
+        assertThat(executionResult2.get().getState().getHistories().get(1).getState()).isEqualTo(State.Type.QUEUED);
+        assertThat(executionResult2.get().getState().getHistories().get(2).getState()).isEqualTo(State.Type.RUNNING);
     }
 
-    public void flowConcurrencyQueuePause() throws QueueException {
-        Execution execution1 = runnerUtils.runOneUntilPaused(MAIN_TENANT, NAMESPACE, "flow-concurrency-queue-pause");
+    public void flowConcurrencyQueuePause() throws TimeoutException, QueueException, InterruptedException {
+        AtomicReference<String> firstExecutionId = new AtomicReference<>();
+        var firstExecutionResult  = new AtomicReference<Execution>();
+        var secondExecutionResult  = new AtomicReference<Execution>();
+
+        CountDownLatch firstExecutionLatch = new CountDownLatch(1);
+        CountDownLatch secondExecutionLatch = new CountDownLatch(1);
+
+        Flux<Execution> receive = TestsUtils.receive(executionQueue, e -> {
+            if (!"flow-concurrency-queue-pause".equals(e.getLeft().getFlowId())){
+                return;
+            }
+            String currentId = e.getLeft().getId();
+            Type currentState = e.getLeft().getState().getCurrent();
+            if (firstExecutionId.get() == null) {
+                firstExecutionId.set(currentId);
+            }
+
+            if (currentId.equals(firstExecutionId.get())) {
+                if (currentState == State.Type.SUCCESS) {
+                    firstExecutionResult.set(e.getLeft());
+                    firstExecutionLatch.countDown();
+                }
+            } else {
+                if (currentState == State.Type.SUCCESS) {
+                    secondExecutionResult.set(e.getLeft());
+                    secondExecutionLatch.countDown();
+                }
+            }
+        });
+
+
+        Execution execution1 = runnerUtils.runOneUntilPaused(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-queue-pause");
         Flow flow = flowRepository
-            .findById(MAIN_TENANT, NAMESPACE, "flow-concurrency-queue-pause", Optional.empty())
+            .findById(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-queue-pause", Optional.empty())
             .orElseThrow();
         Execution execution2 = Execution.newExecution(flow, null, null, Optional.empty());
-        Execution secondExecutionResult = runnerUtils.emitAndAwaitExecution(e -> e.getState().getCurrent().equals(Type.SUCCESS), execution2);
-        Execution firstExecutionResult = runnerUtils.awaitExecution(e -> e.getState().getCurrent().equals(Type.SUCCESS), execution1);
+        executionQueue.emit(execution2);
 
+        assertThat(execution1.getState().isPaused()).isTrue();
+        assertThat(execution2.getState().getCurrent()).isEqualTo(State.Type.CREATED);
 
-        assertThat(firstExecutionResult.getId()).isEqualTo(execution1.getId());
-        assertThat(firstExecutionResult.getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
-        assertThat(secondExecutionResult.getId()).isEqualTo(execution2.getId());
-        assertThat(secondExecutionResult.getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
-        assertThat(secondExecutionResult.getState().getHistories().getFirst().getState()).isEqualTo(State.Type.CREATED);
-        assertThat(secondExecutionResult.getState().getHistories().get(1).getState()).isEqualTo(State.Type.QUEUED);
-        assertThat(secondExecutionResult.getState().getHistories().get(2).getState()).isEqualTo(State.Type.RUNNING);
+        assertTrue(firstExecutionLatch.await(10, TimeUnit.SECONDS));
+        assertTrue(secondExecutionLatch.await(10, TimeUnit.SECONDS));
+        receive.blockLast();
+
+        assertThat(firstExecutionResult.get().getId()).isEqualTo(execution1.getId());
+        assertThat(firstExecutionResult.get().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
+        assertThat(secondExecutionResult.get().getId()).isEqualTo(execution2.getId());
+        assertThat(secondExecutionResult.get().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
+        assertThat(secondExecutionResult.get().getState().getHistories().getFirst().getState()).isEqualTo(State.Type.CREATED);
+        assertThat(secondExecutionResult.get().getState().getHistories().get(1).getState()).isEqualTo(State.Type.QUEUED);
+        assertThat(secondExecutionResult.get().getState().getHistories().get(2).getState()).isEqualTo(State.Type.RUNNING);
     }
 
-    public void flowConcurrencyCancelPause() throws QueueException {
-        Execution execution1 = runnerUtils.runOneUntilPaused(MAIN_TENANT, NAMESPACE, "flow-concurrency-cancel-pause");
+    public void flowConcurrencyCancelPause() throws TimeoutException, QueueException, InterruptedException {
+        AtomicReference<String> firstExecutionId = new AtomicReference<>();
+        var firstExecutionResult  = new AtomicReference<Execution>();
+        var secondExecutionResult  = new AtomicReference<Execution>();
+        CountDownLatch firstExecLatch = new CountDownLatch(1);
+        CountDownLatch secondExecLatch = new CountDownLatch(1);
+
+        Flux<Execution> receive = TestsUtils.receive(executionQueue, e -> {
+            if (!"flow-concurrency-cancel-pause".equals(e.getLeft().getFlowId())){
+                return;
+            }
+            String currentId = e.getLeft().getId();
+            Type currentState = e.getLeft().getState().getCurrent();
+            if (firstExecutionId.get() == null) {
+                firstExecutionId.set(currentId);
+            }
+            if (currentId.equals(firstExecutionId.get())) {
+                if (currentState == State.Type.SUCCESS) {
+                    firstExecutionResult.set(e.getLeft());
+                    firstExecLatch.countDown();
+                }
+            } else {
+                if (currentState == State.Type.CANCELLED) {
+                    secondExecutionResult.set(e.getLeft());
+                    secondExecLatch.countDown();
+                }
+            }
+        });
+
+        Execution execution1 = runnerUtils.runOneUntilPaused(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-cancel-pause");
         Flow flow = flowRepository
-            .findById(MAIN_TENANT, NAMESPACE, "flow-concurrency-cancel-pause", Optional.empty())
+            .findById(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-cancel-pause", Optional.empty())
             .orElseThrow();
         Execution execution2 = Execution.newExecution(flow, null, null, Optional.empty());
-        Execution secondExecutionResult = runnerUtils.emitAndAwaitExecution(e -> e.getState().getCurrent().equals(Type.CANCELLED), execution2);
-        Execution firstExecutionResult = runnerUtils.awaitExecution(e -> e.getState().getCurrent().equals(Type.SUCCESS), execution1);
+        executionQueue.emit(execution2);
 
+        assertThat(execution1.getState().isPaused()).isTrue();
+        assertThat(execution2.getState().getCurrent()).isEqualTo(State.Type.CREATED);
 
-        assertThat(firstExecutionResult.getId()).isEqualTo(execution1.getId());
-        assertThat(firstExecutionResult.getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
-        assertThat(secondExecutionResult.getId()).isEqualTo(execution2.getId());
-        assertThat(secondExecutionResult.getState().getCurrent()).isEqualTo(State.Type.CANCELLED);
-        assertThat(secondExecutionResult.getState().getHistories().getFirst().getState()).isEqualTo(State.Type.CREATED);
-        assertThat(secondExecutionResult.getState().getHistories().get(1).getState()).isEqualTo(State.Type.CANCELLED);
+        assertTrue(firstExecLatch.await(10, TimeUnit.SECONDS));
+        assertTrue(secondExecLatch.await(10, TimeUnit.SECONDS));
+        receive.blockLast();
+
+        assertThat(firstExecutionResult.get().getId()).isEqualTo(execution1.getId());
+        assertThat(firstExecutionResult.get().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
+        assertThat(secondExecutionResult.get().getId()).isEqualTo(execution2.getId());
+        assertThat(secondExecutionResult.get().getState().getCurrent()).isEqualTo(State.Type.CANCELLED);
+        assertThat(secondExecutionResult.get().getState().getHistories().getFirst().getState()).isEqualTo(State.Type.CREATED);
+        assertThat(secondExecutionResult.get().getState().getHistories().get(1).getState()).isEqualTo(State.Type.CANCELLED);
     }
 
-    public void flowConcurrencyWithForEachItem(String tenantId) throws QueueException, URISyntaxException, IOException {
-        URI file = storageUpload(tenantId);
+    public void flowConcurrencyWithForEachItem() throws TimeoutException, QueueException, InterruptedException, URISyntaxException, IOException {
+        URI file = storageUpload();
         Map<String, Object> inputs = Map.of("file", file.toString(), "batch", 4);
-        Execution forEachItem = runnerUtils.runOneUntilRunning(tenantId, NAMESPACE, "flow-concurrency-for-each-item", null,
+        Execution forEachItem = runnerUtils.runOneUntilRunning(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-for-each-item", null,
         (flow, execution1) -> flowIO.readExecutionInputs(flow, execution1, inputs), Duration.ofSeconds(5));
         assertThat(forEachItem.getState().getCurrent()).isEqualTo(Type.RUNNING);
 
+        Set<String> executionIds = new HashSet<>();
+        Flux<Execution> receive = TestsUtils.receive(executionQueue, e -> {
+            if ("flow-concurrency-queue".equals(e.getLeft().getFlowId()) && e.getLeft().getState().isRunning()) {
+                executionIds.add(e.getLeft().getId());
+            }
+        });
 
-        Execution terminated = runnerUtils.awaitExecution(e -> e.getState().isTerminated(),forEachItem);
+        // wait a little to be sure there are not too many executions started
+        Thread.sleep(500);
+
+        assertThat(executionIds).hasSize(1);
+        receive.blockLast();
+
+        Execution terminated = runnerUtils.awaitExecution(e -> e.getId().equals(forEachItem.getId()) && e.getState().isTerminated(), () -> {}, Duration.ofSeconds(10));
         assertThat(terminated.getState().getCurrent()).isEqualTo(Type.SUCCESS);
-
-        List<Execution> executions = runnerUtils.awaitFlowExecutionNumber(2, tenantId, NAMESPACE, "flow-concurrency-queue");
-
-        assertThat(executions).extracting(e -> e.getState().getCurrent()).containsOnly(Type.SUCCESS);
-        assertThat(executions.stream()
-            .map(e -> e.getState().getHistories())
-            .flatMap(List::stream)
-            .map(History::getState)
-            .toList()).contains(Type.QUEUED);
     }
 
     public void flowConcurrencyQueueRestarted() throws Exception {
-        Execution execution1 = runnerUtils.runOneUntilRunning(MAIN_TENANT, NAMESPACE,
-            "flow-concurrency-queue-fail", null, null, Duration.ofSeconds(30));
+        Execution execution1 = runnerUtils.runOneUntilRunning(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-queue-fail", null, null, Duration.ofSeconds(30));
         Flow flow = flowRepository
-            .findById(MAIN_TENANT, NAMESPACE, "flow-concurrency-queue-fail", Optional.empty())
+            .findById(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-queue-fail", Optional.empty())
             .orElseThrow();
         Execution execution2 = Execution.newExecution(flow, null, null, Optional.empty());
-        runnerUtils.emitAndAwaitExecution(e -> e.getState().getCurrent().equals(Type.RUNNING), execution2);
+        executionQueue.emit(execution2);
 
+        assertThat(execution1.getState().isRunning()).isTrue();
+        assertThat(execution2.getState().getCurrent()).isEqualTo(State.Type.CREATED);
+
+        var executionResult1  = new AtomicReference<Execution>();
+        var executionResult2  = new AtomicReference<Execution>();
+
+        CountDownLatch latch1 = new CountDownLatch(2);
+        AtomicReference<Execution> failedExecution = new AtomicReference<>();
+        CountDownLatch latch2 = new CountDownLatch(1);
+        CountDownLatch latch3 = new CountDownLatch(1);
+
+        Flux<Execution> receive = TestsUtils.receive(executionQueue, e -> {
+            if (e.getLeft().getId().equals(execution1.getId())) {
+                executionResult1.set(e.getLeft());
+                if (e.getLeft().getState().getCurrent() == Type.FAILED) {
+                    failedExecution.set(e.getLeft());
+                    latch1.countDown();
+                }
+            }
+
+            if (e.getLeft().getId().equals(execution2.getId())) {
+                executionResult2.set(e.getLeft());
+                if (e.getLeft().getState().getCurrent() == State.Type.RUNNING) {
+                    latch2.countDown();
+                }
+                if (e.getLeft().getState().getCurrent() == Type.FAILED) {
+                    latch3.countDown();
+                }
+            }
+        });
+
+        assertTrue(latch2.await(1, TimeUnit.MINUTES));
+        assertThat(failedExecution.get()).isNotNull();
         // here the first fail and the second is now running.
         // we restart the first one, it should be queued then fail again.
-        Execution failedExecution = runnerUtils.awaitExecution(e -> e.getState().getCurrent().equals(Type.FAILED), execution1);
-        Execution restarted = executionService.restart(failedExecution, null);
-        Execution executionResult1 = runnerUtils.emitAndAwaitExecution(e -> e.getState().getCurrent().equals(Type.FAILED), restarted);
-        Execution executionResult2 = runnerUtils.awaitExecution(e -> e.getState().getCurrent().equals(Type.FAILED), execution2);
+        Execution restarted = executionService.restart(failedExecution.get(), null);
+        executionQueue.emit(restarted);
 
-        assertThat(executionResult1.getState().getCurrent()).isEqualTo(Type.FAILED);
+        assertTrue(latch3.await(1, TimeUnit.MINUTES));
+        assertTrue(latch1.await(1, TimeUnit.MINUTES));
+        receive.blockLast();
+
+        assertThat(executionResult1.get().getState().getCurrent()).isEqualTo(Type.FAILED);
         // it should have been queued after restarted
-        assertThat(executionResult1.getState().getHistories().stream().anyMatch(history -> history.getState() == Type.RESTARTED)).isTrue();
-        assertThat(executionResult1.getState().getHistories().stream().anyMatch(history -> history.getState() == Type.QUEUED)).isTrue();
-        assertThat(executionResult2.getState().getCurrent()).isEqualTo(Type.FAILED);
-        assertThat(executionResult2.getState().getHistories().getFirst().getState()).isEqualTo(State.Type.CREATED);
-        assertThat(executionResult2.getState().getHistories().get(1).getState()).isEqualTo(State.Type.QUEUED);
-        assertThat(executionResult2.getState().getHistories().get(2).getState()).isEqualTo(State.Type.RUNNING);
+        assertThat(executionResult1.get().getState().getHistories().stream().anyMatch(history -> history.getState() == Type.RESTARTED)).isTrue();
+        assertThat(executionResult1.get().getState().getHistories().stream().anyMatch(history -> history.getState() == Type.QUEUED)).isTrue();
+        assertThat(executionResult2.get().getState().getCurrent()).isEqualTo(Type.FAILED);
+        assertThat(executionResult2.get().getState().getHistories().getFirst().getState()).isEqualTo(State.Type.CREATED);
+        assertThat(executionResult2.get().getState().getHistories().get(1).getState()).isEqualTo(State.Type.QUEUED);
+        assertThat(executionResult2.get().getState().getHistories().get(2).getState()).isEqualTo(State.Type.RUNNING);
     }
 
-    public void flowConcurrencyQueueAfterExecution() throws QueueException {
-        Execution execution1 = runnerUtils.runOneUntilRunning(MAIN_TENANT, NAMESPACE, "flow-concurrency-queue-after-execution", null, null, Duration.ofSeconds(30));
+    public void flowConcurrencyQueueAfterExecution() throws TimeoutException, QueueException, InterruptedException {
+        Execution execution1 = runnerUtils.runOneUntilRunning(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-queue-after-execution", null, null, Duration.ofSeconds(30));
         Flow flow = flowRepository
-            .findById(MAIN_TENANT, NAMESPACE, "flow-concurrency-queue-after-execution", Optional.empty())
+            .findById(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-queue-after-execution", Optional.empty())
             .orElseThrow();
         Execution execution2 = Execution.newExecution(flow, null, null, Optional.empty());
-        Execution executionResult2 = runnerUtils.emitAndAwaitExecution(e -> e.getState().getCurrent().equals(Type.SUCCESS), execution2);
-        Execution executionResult1 = runnerUtils.awaitExecution(e -> e.getState().getCurrent().equals(Type.SUCCESS), execution1);
+        executionQueue.emit(execution2);
 
-        assertThat(executionResult1.getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
-        assertThat(executionResult2.getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
-        assertThat(executionResult2.getState().getHistories().getFirst().getState()).isEqualTo(State.Type.CREATED);
-        assertThat(executionResult2.getState().getHistories().get(1).getState()).isEqualTo(State.Type.QUEUED);
-        assertThat(executionResult2.getState().getHistories().get(2).getState()).isEqualTo(State.Type.RUNNING);
+        assertThat(execution1.getState().isRunning()).isTrue();
+        assertThat(execution2.getState().getCurrent()).isEqualTo(State.Type.CREATED);
+
+        var executionResult1  = new AtomicReference<Execution>();
+        var executionResult2  = new AtomicReference<Execution>();
+
+        CountDownLatch latch1 = new CountDownLatch(1);
+        CountDownLatch latch2 = new CountDownLatch(1);
+        CountDownLatch latch3 = new CountDownLatch(1);
+
+        Flux<Execution> receive = TestsUtils.receive(executionQueue, e -> {
+            if (e.getLeft().getId().equals(execution1.getId())) {
+                executionResult1.set(e.getLeft());
+                if (e.getLeft().getState().getCurrent() == State.Type.SUCCESS) {
+                    latch1.countDown();
+                }
+            }
+
+            if (e.getLeft().getId().equals(execution2.getId())) {
+                executionResult2.set(e.getLeft());
+                if (e.getLeft().getState().getCurrent() == State.Type.RUNNING) {
+                    latch2.countDown();
+                }
+                if (e.getLeft().getState().getCurrent() == State.Type.SUCCESS) {
+                    latch3.countDown();
+                }
+            }
+        });
+
+        assertTrue(latch1.await(1, TimeUnit.MINUTES));
+        assertTrue(latch2.await(1, TimeUnit.MINUTES));
+        assertTrue(latch3.await(1, TimeUnit.MINUTES));
+        receive.blockLast();
+
+        assertThat(executionResult1.get().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
+        assertThat(executionResult2.get().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
+        assertThat(executionResult2.get().getState().getHistories().getFirst().getState()).isEqualTo(State.Type.CREATED);
+        assertThat(executionResult2.get().getState().getHistories().get(1).getState()).isEqualTo(State.Type.QUEUED);
+        assertThat(executionResult2.get().getState().getHistories().get(2).getState()).isEqualTo(State.Type.RUNNING);
     }
 
-    public void flowConcurrencySubflow(String tenantId) throws TimeoutException, QueueException {
-        runnerUtils.runOneUntilRunning(tenantId, NAMESPACE, "flow-concurrency-subflow", null, null, Duration.ofSeconds(30));
-        runnerUtils.runOne(tenantId, NAMESPACE, "flow-concurrency-subflow");
+    public void flowConcurrencySubflow() throws TimeoutException, QueueException, InterruptedException {
+        CountDownLatch successLatch = new CountDownLatch(1);
+        CountDownLatch canceledLatch = new CountDownLatch(1);
+        Flux<Execution> receive = TestsUtils.receive(executionQueue, e -> {
+            if (e.getLeft().getFlowId().equals("flow-concurrency-cancel")) {
+                if (e.getLeft().getState().getCurrent() == State.Type.SUCCESS) {
+                    successLatch.countDown();
+                }
+                if (e.getLeft().getState().getCurrent() == Type.CANCELLED) {
+                    canceledLatch.countDown();
+                }
+            }
 
-        List<Execution> subFlowExecs = runnerUtils.awaitFlowExecutionNumber(2, tenantId, NAMESPACE, "flow-concurrency-cancel");
-        assertThat(subFlowExecs).extracting(e -> e.getState().getCurrent()).containsExactlyInAnyOrder(Type.SUCCESS, Type.CANCELLED);
+            // FIXME we should fail if we receive the cancel execution again but on Kafka it happens
+        });
+
+        Execution execution1 = runnerUtils.runOneUntilRunning(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-subflow", null, null, Duration.ofSeconds(30));
+        Execution execution2 = runnerUtils.runOne(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-subflow");
+
+        assertThat(execution1.getState().isRunning()).isTrue();
+        assertThat(execution2.getState().getCurrent()).isEqualTo(Type.SUCCESS);
+
+        // assert we have one canceled subflow and one in success
+        assertTrue(canceledLatch.await(1, TimeUnit.MINUTES));
+        assertTrue(successLatch.await(1, TimeUnit.MINUTES));
+        receive.blockLast();
 
         // run another execution to be sure that everything work (purge is correctly done)
-        Execution execution3 = runnerUtils.runOne(tenantId, NAMESPACE, "flow-concurrency-subflow");
+        CountDownLatch newSuccessLatch = new CountDownLatch(1);
+        Flux<Execution> secondReceive = TestsUtils.receive(executionQueue, e -> {
+            if (e.getLeft().getFlowId().equals("flow-concurrency-cancel")) {
+                if (e.getLeft().getState().getCurrent() == State.Type.SUCCESS) {
+                    newSuccessLatch.countDown();
+                }
+            }
+
+            // FIXME we should fail if we receive the cancel execution again but on Kafka it happens
+        });
+        Execution execution3 = runnerUtils.runOne(MAIN_TENANT, "io.kestra.tests", "flow-concurrency-subflow");
         assertThat(execution3.getState().getCurrent()).isEqualTo(Type.SUCCESS);
-        runnerUtils.awaitFlowExecution(e -> e.getState().getCurrent().equals(Type.SUCCESS), tenantId, NAMESPACE, "flow-concurrency-cancel");
+
+        // assert we have two successful subflow
+        assertTrue(newSuccessLatch.await(1, TimeUnit.MINUTES));
+        secondReceive.blockLast();
     }
 
-    private URI storageUpload(String tenantId) throws URISyntaxException, IOException {
+    private URI storageUpload() throws URISyntaxException, IOException {
         File tempFile = File.createTempFile("file", ".txt");
 
         Files.write(tempFile.toPath(), content());
 
         return storageInterface.put(
-            tenantId,
+            MAIN_TENANT,
             null,
             new URI("/file/storage/file.txt"),
             new FileInputStream(tempFile)

core/src/test/java/io/kestra/core/runners/FlowInputOutputTest.java

@@ -10,11 +10,14 @@ import io.kestra.core.models.flows.input.InputAndValue;
 import io.kestra.core.models.flows.input.IntInput;
 import io.kestra.core.models.flows.input.StringInput;
 import io.kestra.core.models.property.Property;
+import io.kestra.core.secret.SecretNotFoundException;
+import io.kestra.core.secret.SecretService;
 import io.kestra.core.storages.StorageInterface;
 import io.kestra.core.utils.IdUtils;
 import io.micronaut.http.MediaType;
 import io.micronaut.http.multipart.CompletedFileUpload;
 import io.micronaut.http.multipart.CompletedPart;
+import io.micronaut.test.annotation.MockBean;
 import jakarta.inject.Inject;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -34,7 +37,9 @@ import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 
 @KestraTest
 class FlowInputOutputTest {
-
+    
+    private static final String TEST_SECRET_VALUE = "test-secret-value";
+    
     static final Execution DEFAULT_TEST_EXECUTION = Execution.builder()
         .id(IdUtils.create())
         .flowId(IdUtils.create())
@@ -47,7 +52,17 @@ class FlowInputOutputTest {
 
     @Inject
     StorageInterface storageInterface;
-
+    
+    @MockBean(SecretService.class)
+    SecretService testSecretService() {
+        return new SecretService() {
+            @Override
+            public String findSecret(String tenantId, String namespace, String key) throws SecretNotFoundException {
+                return TEST_SECRET_VALUE;
+            }
+        };
+    }
+    
     @Test
     void shouldResolveEnabledInputsGivenInputWithConditionalExpressionMatchingTrue() {
         // Given
@@ -285,44 +300,86 @@ class FlowInputOutputTest {
             values
         );
     }
-
-    private static final class MemoryCompletedFileUpload implements CompletedFileUpload {
-
-        private final String name;
-        private final String fileName;
-        private final byte[] content;
-
-        public MemoryCompletedFileUpload(String name, String fileName, byte[] content) {
+    
+    @Test
+    void shouldObfuscateSecretsWhenValidatingInputs() {
+        // Given
+        StringInput input = StringInput.builder()
+            .id("input")
+            .type(Type.STRING)
+            .defaults(Property.ofExpression("{{ secret('???') }}"))
+            .required(false)
+            .build();
+        
+        // When
+        List<InputAndValue> results = flowInputOutput.validateExecutionInputs(List.of(input), null, DEFAULT_TEST_EXECUTION, Mono.empty()).block();
+        
+        // Then
+        Assertions.assertEquals("******", results.getFirst().value());
+    }
+    
+    @Test
+    void shouldNotObfuscateSecretsWhenReadingInputs() {
+        // Given
+        StringInput input = StringInput.builder()
+            .id("input")
+            .type(Type.STRING)
+            .defaults(Property.ofExpression("{{ secret('???') }}"))
+            .required(false)
+            .build();
+        
+        // When
+        Map<String, Object> results = flowInputOutput.readExecutionInputs(List.of(input), null, DEFAULT_TEST_EXECUTION, Mono.empty()).block();
+        
+        // Then
+        Assertions.assertEquals(TEST_SECRET_VALUE, results.get("input"));
+    }
+    
+    private static class MemoryCompletedPart implements CompletedPart {
+        
+        protected final String name;
+        protected final byte[] content;
+        
+        public MemoryCompletedPart(String name, byte[] content) {
             this.name = name;
-            this.fileName = fileName;
             this.content = content;
         }
-
+        
         @Override
         public InputStream getInputStream() {
             return new ByteArrayInputStream(content);
         }
-
+        
         @Override
         public byte[] getBytes() {
             return content;
         }
-
+        
         @Override
         public ByteBuffer getByteBuffer() {
             return ByteBuffer.wrap(content);
         }
-
+        
         @Override
         public Optional<MediaType> getContentType() {
             return Optional.empty();
         }
-
+        
         @Override
         public String getName() {
             return name;
         }
+    }
+    
+    private static final class MemoryCompletedFileUpload extends MemoryCompletedPart implements CompletedFileUpload {
 
+        private final String fileName;
+
+        public MemoryCompletedFileUpload(String name, String fileName, byte[] content) {
+            super(name, content);
+            this.fileName = fileName;
+        }
+        
         @Override
         public String getFilename() {
             return fileName;