fix(executions): make state_duration generated on queries

- fixes https://github.com/kestra-io/kestra/issues/11593

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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,85 @@
+# 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-scheduling.yml

@@ -0,0 +1,15 @@
+name: 'E2E tests scheduling'
+# '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_dispatch:
+    inputs:
+      noInputYet:
+        description: 'not input yet.'
+        required: false
+        type: string
+        default: "no input"
+jobs:
+  e2e:
+    uses: kestra-io/actions/.github/workflows/kestra-oss-e2e-tests.yml@main

.github/workflows/global-create-new-release-branch.yml

@@ -0,0 +1,84 @@
+name: Create new release branch
+run-name: "Create new release branch 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/global-gradle-release-plugins.yml

@@ -0,0 +1,74 @@
+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: kestra-io/actions/composite/kestra-oss/kestra-oss-plugins-list@main
+        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/global-setversion-tag-plugins.yml

@@ -0,0 +1,60 @@
+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: kestra-io/actions/composite/kestra-oss/kestra-oss-plugins-list@main
+        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/global-start-release.yml

@@ -0,0 +1,65 @@
+name: Start release
+run-name: "Start release of Kestra ${{ github.event.inputs.releaseVersion }} 🚀"
+on:
+  workflow_dispatch:
+    inputs:
+      releaseVersion:
+        description: 'The release version (e.g., 0.21.1)'
+        required: true
+        type: string
+
+permissions:
+  contents: write
+
+env:
+  RELEASE_VERSION: "${{ github.event.inputs.releaseVersion }}"
+jobs:
+  release:
+    name: Release Kestra
+    runs-on: ubuntu-latest
+    steps:
+      - name: Parse and Check Inputs
+        id: parse-and-check-inputs
+        run: |
+          CURRENT_BRANCH="${{ github.ref_name }}"
+          if ! [[ "$CURRENT_BRANCH" == "develop" ]]; then
+            echo "You can only run this workflow on develop, but you ran it on $CURRENT_BRANCH"
+            exit 1
+          fi
+
+          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="releases/v${BASE_VERSION}.x"
+          echo "release_branch=${RELEASE_BRANCH}" >> $GITHUB_OUTPUT
+
+      # Checkout
+      - name: Checkout
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GH_PERSONAL_TOKEN }}
+          ref: ${{ steps.parse-and-check-inputs.outputs.release_branch }}
+
+      # 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: Start release by updating version and pushing a new tag
+        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/pre-release.yml

@@ -5,15 +5,6 @@ on:
     tags:
       - 'v*'
   workflow_dispatch:
-    inputs:
-      skip-test:
-        description: 'Skip test'
-        type: choice
-        required: true
-        default: 'false'
-        options:
-          - "true"
-          - "false"
 
 jobs:
   build-artifacts:
@@ -23,7 +14,6 @@ jobs:
   backend-tests:
     name: Backend tests
     uses: kestra-io/actions/.github/workflows/kestra-oss-backend-tests.yml@main
-    if: ${{ github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '' }}
     secrets:
       GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
@@ -33,7 +23,6 @@ jobs:
   frontend-tests:
     name: Frontend tests
     uses: kestra-io/actions/.github/workflows/kestra-oss-frontend-tests.yml@main
-    if: ${{ github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '' }}
     secrets:
       GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/release-docker.yml

@@ -13,11 +13,11 @@ on:
         required: true
         type: boolean
         default: false
-      dry-run:
-        description: 'Dry run mode that will not write or release anything'
-        required: true
-        type: boolean
-        default: false
+      plugin-version:
+        description: 'Plugin version'
+        required: false
+        type: string
+        default: "LATEST"
 
 jobs:
   publish-docker:
@@ -25,9 +25,9 @@ jobs:
     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 }}
-      dry-run: ${{ inputs.dry-run }}
     secrets:
       DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
       DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}

.github/workflows/vulnerabilities-check.yml

@@ -22,11 +22,12 @@ jobs:
           fetch-depth: 0
 
       # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
+      - uses: ./actions/.github/actions/setup-build
         id: build
         with:
           java-enabled: true
           node-enabled: true
+          caches-enabled: true
 
       # Npm
       - name: Npm - Install
@@ -48,3 +49,77 @@ 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'

Dockerfile.pr

@@ -1,5 +1,4 @@
-ARG KESTRA_DOCKER_BASE_VERSION=develop
-FROM  kestra/kestra:$KESTRA_DOCKER_BASE_VERSION
+FROM  kestra/kestra:develop
 
 USER root
 

README.md

@@ -19,9 +19,12 @@
 <br />
 
 <p align="center">
-    <a href="https://x.com/kestra_io"><img height="25" src="https://kestra.io/twitter.svg" alt="X(formerly Twitter)" /></a> &nbsp;
-    <a href="https://www.linkedin.com/company/kestra/"><img height="25" src="https://kestra.io/linkedin.svg" alt="linkedin" /></a> &nbsp;
-<a href="https://www.youtube.com/@kestra-io"><img height="25" src="https://kestra.io/youtube.svg" alt="youtube" /></a> &nbsp;
+  <a href="https://twitter.com/kestra_io" style="margin: 0 10px;">
+        <img height="25" src="https://kestra.io/twitter.svg" alt="twitter" width="35" height="25" /></a>
+  <a href="https://www.linkedin.com/company/kestra/" style="margin: 0 10px;">
+        <img height="25" src="https://kestra.io/linkedin.svg" alt="linkedin" width="35" height="25" /></a> 
+  <a href="https://www.youtube.com/@kestra-io" style="margin: 0 10px;">
+        <img height="25" src="https://kestra.io/youtube.svg" alt="youtube" width="35" height="25" /></a>
 </p>
 
 <p align="center">
@@ -33,10 +36,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 4 minutes with Kestra" width="640px" />
+        <img src="https://kestra.io/startvideo.png" alt="Get started in 3 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 4 minutes.</i></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>
 
 
 ## 🌟 What is Kestra?

build.gradle

@@ -25,19 +25,19 @@ plugins {
     id 'jacoco-report-aggregation'
 
     // helper
-    id "com.github.ben-manes.versions" version "0.52.0"
+    id "com.github.ben-manes.versions" version "0.53.0"
 
     // front
     id 'com.github.node-gradle.node' version '7.1.0'
 
     // release
     id 'net.researchgate.release' version '3.1.0'
-    id "com.gorylenko.gradle-git-properties" version "2.5.2"
+    id "com.gorylenko.gradle-git-properties" version "2.5.3"
     id 'signing'
     id "com.vanniktech.maven.publish" version "0.34.0"
 
     // OWASP dependency check
-    id "org.owasp.dependencycheck" version "12.1.3" apply false
+    id "org.owasp.dependencycheck" version "12.1.5" apply false
 }
 
 idea {
@@ -168,8 +168,9 @@ allprojects {
 /**********************************************************************************************************************\
  * Test
  **********************************************************************************************************************/
-subprojects {
-    if (it.name != 'platform' && it.name != 'jmh-benchmarks') {
+subprojects {subProj ->
+
+    if (subProj.name != 'platform' && subProj.name != 'jmh-benchmarks') {
         apply plugin: "com.adarshr.test-logger"
 
         java {
@@ -205,59 +206,39 @@ subprojects {
             testImplementation 'org.assertj:assertj-core'
         }
 
-        def commonTestConfig = { Test t ->
-            // set Xmx for test workers
-            t.maxHeapSize = '4g'
-
-            // configure en_US default locale for tests
-            t.systemProperty 'user.language', 'en'
-            t.systemProperty 'user.country', 'US'
-
-            t.environment 'SECRET_MY_SECRET', "{\"secretKey\":\"secretValue\"}".bytes.encodeBase64().toString()
-            t.environment 'SECRET_NEW_LINE', "cGFzc3dvcmR2ZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2ZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2\nZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2ZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2ZXJ5dmVyeXZl\neXJsb25n"
-            t.environment 'SECRET_WEBHOOK_KEY', "secretKey".bytes.encodeBase64().toString()
-            t.environment 'SECRET_NON_B64_SECRET', "some secret value"
-            t.environment 'SECRET_PASSWORD', "cGFzc3dvcmQ="
-            t.environment 'ENV_TEST1', "true"
-            t.environment 'ENV_TEST2', "Pass by env"
-
-        }
-
-        tasks.register('flakyTest', Test) { Test t ->
-            group = 'verification'
-            description = 'Runs tests tagged @Flaky but does not fail the build.'
-
-            useJUnitPlatform {
-                includeTags 'flaky'
-            }
-            ignoreFailures = true
-
-            reports {
-                junitXml.required = true
-                junitXml.outputPerTestCase = true
-                junitXml.mergeReruns = true
-                junitXml.includeSystemErrLog = true
-                junitXml.outputLocation = layout.buildDirectory.dir("test-results/flakyTest")
-            }
-            commonTestConfig(t)
-
-        }
-
         test {
-            useJUnitPlatform {
-                excludeTags 'flaky'
-            }
+            useJUnitPlatform()
             reports {
                 junitXml.required = true
                 junitXml.outputPerTestCase = true
                 junitXml.mergeReruns = true
-                junitXml.includeSystemErrLog = true
+                junitXml.includeSystemErrLog = true;
                 junitXml.outputLocation = layout.buildDirectory.dir("test-results/test")
             }
-            commonTestConfig(it)
+
+            // set Xmx for test workers
+            maxHeapSize = '4g'
+
+            // configure en_US default locale for tests
+            systemProperty 'user.language', 'en'
+            systemProperty 'user.country', 'US'
+
+            environment 'SECRET_MY_SECRET', "{\"secretKey\":\"secretValue\"}".bytes.encodeBase64().toString()
+            environment 'SECRET_NEW_LINE', "cGFzc3dvcmR2ZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2ZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2\nZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2ZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2ZXJ5dmVyeXZl\neXJsb25n"
+            environment 'SECRET_WEBHOOK_KEY', "secretKey".bytes.encodeBase64().toString()
+            environment 'SECRET_NON_B64_SECRET', "some secret value"
+            environment 'SECRET_PASSWORD', "cGFzc3dvcmQ="
+            environment 'ENV_TEST1', "true"
+            environment 'ENV_TEST2', "Pass by env"
 
 
-            finalizedBy(tasks.named('flakyTest'))
+            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,5 +40,6 @@ dependencies {
     implementation project(":worker")
 
     //test
+    testImplementation project(':tests')
     testImplementation "org.wiremock:wiremock-jetty12"
 }

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

@@ -117,7 +117,7 @@ public abstract class AbstractValidateCommand extends AbstractApiCommand {
 
             try(DefaultHttpClient client = client()) {
                 MutableHttpRequest<String> request = HttpRequest
-                    .POST(apiUri("/flows/validate", tenantService.getTenantIdAndAllowEETenants(tenantId)), body).contentType(MediaType.APPLICATION_YAML);
+                    .POST(apiUri("/flows/validate", tenantService.getTenantId(tenantId)), body).contentType(MediaType.APPLICATION_YAML);
 
                 List<ValidateConstraintViolation> validations = client.toBlocking().retrieve(
                     this.requestOptions(request),

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, args);
+        execute(App.class, new String [] { Environment.CLI }, 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... args) {
+    protected static void execute(Class<?> cls, String[] environments, String... args) {
         // Log Bridge
         SLF4JBridgeHandler.removeHandlersForRootLogger();
         SLF4JBridgeHandler.install();
 
         // Init ApplicationContext
-        ApplicationContext applicationContext = App.applicationContext(cls, args);
+        ApplicationContext applicationContext = App.applicationContext(cls, environments, args);
 
         // Call Picocli command
         int exitCode = 0;
@@ -80,6 +80,7 @@ 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.
@@ -88,12 +89,13 @@ 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(Environment.CLI);
+            .environments(environments);
 
         CommandLine cmd = new CommandLine(mainClass, CommandLine.defaultFactory());
         continueOnParsingErrors(cmd);

cli/src/main/java/io/kestra/cli/commands/flows/FlowValidateCommand.java

@@ -24,8 +24,7 @@ public class FlowValidateCommand extends AbstractValidateCommand {
     private FlowService flowService;
 
     @Inject
-    private TenantIdSelectorService tenantIdSelectorService;
-
+    private TenantIdSelectorService tenantService;
 
     @Override
     public Integer call() throws Exception {
@@ -40,7 +39,7 @@ public class FlowValidateCommand extends AbstractValidateCommand {
                 FlowWithSource flow = (FlowWithSource) object;
                 List<String> warnings = new ArrayList<>();
                 warnings.addAll(flowService.deprecationPaths(flow).stream().map(deprecation -> deprecation + " is deprecated").toList());
-                warnings.addAll(flowService.warnings(flow, tenantIdSelectorService.getTenantIdAndAllowEETenants(tenantId)));
+                warnings.addAll(flowService.warnings(flow, tenantService.getTenantId(tenantId)));
                 return warnings;
             },
             (Object object) -> {

cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceUpdateCommand.java

@@ -64,7 +64,7 @@ public class FlowNamespaceUpdateCommand extends AbstractServiceNamespaceUpdateCo
             }
             try(DefaultHttpClient client = client()) {
                 MutableHttpRequest<String> request = HttpRequest
-                    .POST(apiUri("/flows/", tenantService.getTenantIdAndAllowEETenants(tenantId)) + namespace + "?delete=" + delete, body).contentType(MediaType.APPLICATION_YAML);
+                    .POST(apiUri("/flows/", tenantService.getTenantId(tenantId)) + namespace + "?delete=" + delete, body).contentType(MediaType.APPLICATION_YAML);
 
                 List<UpdateResult> updated = client.toBlocking().retrieve(
                     this.requestOptions(request),

cli/src/main/java/io/kestra/cli/commands/namespaces/files/NamespaceFilesUpdateCommand.java

@@ -49,7 +49,7 @@ public class NamespaceFilesUpdateCommand extends AbstractApiCommand {
 
         try (var files = Files.walk(from); DefaultHttpClient client = client()) {
             if (delete) {
-                client.toBlocking().exchange(this.requestOptions(HttpRequest.DELETE(apiUri("/namespaces/", tenantService.getTenantIdAndAllowEETenants(tenantId)) + namespace + "/files?path=" + to, null)));
+                client.toBlocking().exchange(this.requestOptions(HttpRequest.DELETE(apiUri("/namespaces/", tenantService.getTenantId(tenantId)) + namespace + "/files?path=" + to, null)));
             }
 
             KestraIgnore kestraIgnore = new KestraIgnore(from);
@@ -67,7 +67,7 @@ public class NamespaceFilesUpdateCommand extends AbstractApiCommand {
                 client.toBlocking().exchange(
                     this.requestOptions(
                         HttpRequest.POST(
-                            apiUri("/namespaces/", tenantService.getTenantIdAndAllowEETenants(tenantId)) + namespace + "/files?path=" + destination,
+                            apiUri("/namespaces/", tenantService.getTenantId(tenantId)) + namespace + "/files?path=" + destination,
                             body
                         ).contentType(MediaType.MULTIPART_FORM_DATA)
                     )

cli/src/main/java/io/kestra/cli/commands/namespaces/kv/KvUpdateCommand.java

@@ -62,7 +62,7 @@ public class KvUpdateCommand extends AbstractApiCommand {
         Duration ttl = expiration == null ? null : Duration.parse(expiration);
         MutableHttpRequest<String> request = HttpRequest
             .PUT(apiUri("/namespaces/", tenantService.getTenantId(tenantId)) + namespace + "/kv/" + key, value)
-            .contentType(MediaType.TEXT_PLAIN);
+            .contentType(MediaType.APPLICATION_JSON_TYPE);
 
         if (ttl != null) {
             request.header("ttl", ttl.toString());

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

@@ -2,19 +2,27 @@ package io.kestra.cli.commands.servers;
 
 import io.kestra.cli.AbstractCommand;
 import io.kestra.core.contexts.KestraContext;
-import jakarta.annotation.PostConstruct;
+import lombok.extern.slf4j.Slf4j;
 import picocli.CommandLine;
 
-abstract public class AbstractServerCommand extends AbstractCommand implements ServerCommandInterface {
+@Slf4j
+public abstract 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

@@ -1,9 +1,7 @@
 package io.kestra.cli.commands.servers;
 
 import com.google.common.collect.ImmutableMap;
-import io.kestra.cli.services.TenantIdSelectorService;
 import io.kestra.core.models.ServerType;
-import io.kestra.core.repositories.LocalFlowRepositoryLoader;
 import io.kestra.core.runners.ExecutorInterface;
 import io.kestra.core.services.SkipExecutionService;
 import io.kestra.core.services.StartExecutorService;
@@ -12,8 +10,6 @@ import io.micronaut.context.ApplicationContext;
 import jakarta.inject.Inject;
 import picocli.CommandLine;
 
-import java.io.File;
-import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -23,9 +19,6 @@ import java.util.Map;
     description = "Start the Kestra executor"
 )
 public class ExecutorCommand extends AbstractServerCommand {
-    @CommandLine.Spec
-    CommandLine.Model.CommandSpec spec;
-
     @Inject
     private ApplicationContext applicationContext;
 
@@ -35,28 +28,22 @@ public class ExecutorCommand extends AbstractServerCommand {
     @Inject
     private StartExecutorService startExecutorService;
 
-    @CommandLine.Option(names = {"-f", "--flow-path"}, description = "Tenant identifier required to load flows from the specified path")
-    private File flowPath;
-
-    @CommandLine.Option(names = "--tenant", description = "Tenant identifier, Required to load flows from path")
-    private String tenantId;
-
-    @CommandLine.Option(names = {"--skip-executions"}, split=",", description = "List of execution IDs to skip, separated by commas; for troubleshooting only")
+    @CommandLine.Option(names = {"--skip-executions"}, split=",", description = "The list of execution identifiers to skip, separated by a coma; for troubleshooting purpose only")
     private List<String> skipExecutions = Collections.emptyList();
 
-    @CommandLine.Option(names = {"--skip-flows"}, split=",", description = "List of flow identifiers (tenant|namespace|flowId) to skip, separated by a coma; for troubleshooting only")
+    @CommandLine.Option(names = {"--skip-flows"}, split=",", description = "The list of flow identifiers (tenant|namespace|flowId) to skip, separated by a coma; for troubleshooting purpose only")
     private List<String> skipFlows = Collections.emptyList();
 
-    @CommandLine.Option(names = {"--skip-namespaces"}, split=",", description = "List of namespace identifiers (tenant|namespace) to skip, separated by a coma; for troubleshooting only")
+    @CommandLine.Option(names = {"--skip-namespaces"}, split=",", description = "The list of namespace identifiers (tenant|namespace) to skip, separated by a coma; for troubleshooting purpose only")
     private List<String> skipNamespaces = Collections.emptyList();
 
-    @CommandLine.Option(names = {"--skip-tenants"}, split=",", description = "List of tenants to skip, separated by a coma; for troubleshooting only")
+    @CommandLine.Option(names = {"--skip-tenants"}, split=",", description = "The list of tenants to skip, separated by a coma; for troubleshooting purpose only")
     private List<String> skipTenants = Collections.emptyList();
 
-    @CommandLine.Option(names = {"--start-executors"}, split=",", description = "List of Kafka Stream executors to start, separated by a command. Use it only with the Kafka queue; for debugging only")
+    @CommandLine.Option(names = {"--start-executors"}, split=",", description = "The list of Kafka Stream executors to start, separated by a command. Use it only with the Kafka queue, for debugging purpose.")
     private List<String> startExecutors = Collections.emptyList();
 
-    @CommandLine.Option(names = {"--not-start-executors"}, split=",", description = "Lst of Kafka Stream executors to not start, separated by a command. Use it only with the Kafka queue; for debugging only")
+    @CommandLine.Option(names = {"--not-start-executors"}, split=",", description = "The list of Kafka Stream executors to not start, separated by a command. Use it only with the Kafka queue, for debugging purpose.")
     private List<String> notStartExecutors = Collections.emptyList();
 
     @SuppressWarnings("unused")
@@ -77,16 +64,6 @@ public class ExecutorCommand extends AbstractServerCommand {
 
         super.call();
 
-        if (flowPath != null) {
-            try {
-                LocalFlowRepositoryLoader localFlowRepositoryLoader = applicationContext.getBean(LocalFlowRepositoryLoader.class);
-                TenantIdSelectorService tenantIdSelectorService = applicationContext.getBean(TenantIdSelectorService.class);
-                localFlowRepositoryLoader.load(tenantIdSelectorService.getTenantId(this.tenantId), this.flowPath);
-            } catch (IOException e) {
-                throw new CommandLine.ParameterException(this.spec.commandLine(), "Invalid flow path", e);
-            }
-        }
-
         ExecutorInterface executorService = applicationContext.getBean(ExecutorInterface.class);
         executorService.run();
 

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

@@ -23,7 +23,7 @@ public class IndexerCommand extends AbstractServerCommand {
     @Inject
     private SkipExecutionService skipExecutionService;
 
-    @CommandLine.Option(names = {"--skip-indexer-records"}, split=",", description = "a list of indexer record keys, separated by a coma; for troubleshooting only")
+    @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")

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

@@ -42,7 +42,7 @@ public class StandAloneCommand extends AbstractServerCommand {
     @Nullable
     private FileChangedEventListener fileWatcher;
 
-    @CommandLine.Option(names = {"-f", "--flow-path"}, description = "Tenant identifier required to load flows from the specified path")
+    @CommandLine.Option(names = {"-f", "--flow-path"}, description = "the flow path containing flow to inject at startup (when running with a memory flow repository)")
     private File flowPath;
 
     @CommandLine.Option(names = "--tenant", description = "Tenant identifier, Required to load flows from path with the enterprise edition")
@@ -51,19 +51,19 @@ public class StandAloneCommand extends AbstractServerCommand {
     @CommandLine.Option(names = {"--worker-thread"}, description = "the number of worker threads, defaults to eight times the number of available processors. Set it to 0 to avoid starting a worker.")
     private int workerThread = defaultWorkerThread();
 
-    @CommandLine.Option(names = {"--skip-executions"}, split=",", description = "a list of execution identifiers to skip, separated by a coma; for troubleshooting only")
+    @CommandLine.Option(names = {"--skip-executions"}, split=",", description = "a list of execution identifiers to skip, separated by a coma; for troubleshooting purpose only")
     private List<String> skipExecutions = Collections.emptyList();
 
-    @CommandLine.Option(names = {"--skip-flows"}, split=",", description = "a list of flow identifiers (namespace.flowId) to skip, separated by a coma; for troubleshooting only")
+    @CommandLine.Option(names = {"--skip-flows"}, split=",", description = "a list of flow identifiers (namespace.flowId) to skip, separated by a coma; for troubleshooting purpose only")
     private List<String> skipFlows = Collections.emptyList();
 
-    @CommandLine.Option(names = {"--skip-namespaces"}, split=",", description = "a list of namespace identifiers (tenant|namespace) to skip, separated by a coma; for troubleshooting only")
+    @CommandLine.Option(names = {"--skip-namespaces"}, split=",", description = "a list of namespace identifiers (tenant|namespace) to skip, separated by a coma; for troubleshooting purpose only")
     private List<String> skipNamespaces = Collections.emptyList();
 
-    @CommandLine.Option(names = {"--skip-tenants"}, split=",", description = "a list of tenants to skip, separated by a coma; for troubleshooting only")
+    @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 only")
+    @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.")

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

@@ -40,7 +40,7 @@ public class WebServerCommand extends AbstractServerCommand {
     @Option(names = {"--no-indexer"}, description = "Flag to disable starting an embedded indexer.")
     private boolean indexerDisabled = false;
 
-    @CommandLine.Option(names = {"--skip-indexer-records"}, split=",", description = "a list of indexer record keys, separated by a coma; for troubleshooting only")
+    @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

cli/src/main/java/io/kestra/cli/commands/sys/SubmitQueuedCommand.java

@@ -6,7 +6,6 @@ import io.kestra.core.models.flows.State;
 import io.kestra.core.queues.QueueFactoryInterface;
 import io.kestra.core.queues.QueueInterface;
 import io.kestra.core.runners.ExecutionQueued;
-import io.kestra.core.services.ConcurrencyLimitService;
 import io.kestra.jdbc.runner.AbstractJdbcExecutionQueuedStorage;
 import io.micronaut.context.ApplicationContext;
 import jakarta.inject.Inject;
@@ -16,6 +15,8 @@ import picocli.CommandLine;
 
 import java.util.Optional;
 
+import static io.kestra.core.utils.Rethrow.throwConsumer;
+
 @CommandLine.Command(
     name = "submit-queued-execution",
     description = {"Submit all queued execution to the executor",
@@ -48,11 +49,9 @@ public class SubmitQueuedCommand extends AbstractCommand {
         }
         else if (queueType.get().equals("postgres") || queueType.get().equals("mysql") || queueType.get().equals("h2")) {
             var executionQueuedStorage = applicationContext.getBean(AbstractJdbcExecutionQueuedStorage.class);
-            var concurrencyLimitService = applicationContext.getBean(ConcurrencyLimitService.class);
 
             for (ExecutionQueued queued : executionQueuedStorage.getAllForAllTenants()) {
-                Execution restart = concurrencyLimitService.unqueue(queued.getExecution(), State.Type.RUNNING);
-                executionQueue.emit(restart);
+                executionQueuedStorage.pop(queued.getTenantId(), queued.getNamespace(), queued.getFlowId(), throwConsumer(execution -> executionQueue.emit(execution.withState(State.Type.CREATED))));
                 cpt++;
             }
         }

cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceUpdateCommand.java

@@ -49,7 +49,7 @@ public class TemplateNamespaceUpdateCommand extends AbstractServiceNamespaceUpda
 
             try (DefaultHttpClient client = client()) {
                 MutableHttpRequest<List<Template>> request = HttpRequest
-                    .POST(apiUri("/templates/", tenantService.getTenantIdAndAllowEETenants(tenantId)) + namespace + "?delete=" + delete, templates);
+                    .POST(apiUri("/templates/", tenantService.getTenantId(tenantId)) + namespace + "?delete=" + delete, templates);
 
                 List<UpdateResult> updated = client.toBlocking().retrieve(
                     this.requestOptions(request),

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

@@ -262,6 +262,8 @@ 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/java/io/kestra/cli/services/TenantIdSelectorService.java

@@ -16,11 +16,4 @@ public class TenantIdSelectorService {
         }
         return MAIN_TENANT;
     }
-
-    public String getTenantIdAndAllowEETenants(String tenantId) {
-        if (StringUtils.isNotBlank(tenantId)){
-            return tenantId;
-        }
-        return MAIN_TENANT;
-    }
 }

cli/src/main/resources/application.yml

@@ -30,15 +30,15 @@ micronaut:
     read-idle-timeout: 60m
     write-idle-timeout: 60m
     idle-timeout: 60m
+    netty:
+      max-zstd-encode-size: 67108864 # increased to 64MB from the default of 32MB
+      max-chunk-size: 10MB
+      max-header-size: 32768 # increased from the default of 8k
     responses:
       file:
         cache-seconds: 86400
         cache-control:
           public: true
-    netty:
-      max-zstd-encode-size: 67108864 # increased to 64MB from the default of 32MB
-      max-chunk-size: 10MB
-      max-header-size: 32768 # increased from the default of 8k
 
       # Access log configuration, see https://docs.micronaut.io/latest/guide/index.html#accessLogger
       access-logger:

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, args)) {
+        try (ApplicationContext ctx = App.applicationContext(App.class, new String [] { Environment.CLI }, 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, argsWithMissingParams)) {
+        try (ApplicationContext ctx = App.applicationContext(App.class, new String [] { Environment.CLI }, argsWithMissingParams)) {
             new CommandLine(App.class, new MicronautFactory(ctx)).execute(argsWithMissingParams);
 
             assertThat(out.toString()).startsWith("Missing required parameters: ");

cli/src/test/java/io/kestra/cli/commands/flows/FlowValidateCommandTest.java

@@ -27,26 +27,6 @@ class FlowValidateCommandTest {
         }
     }
 
-    @Test
-     // github action kestra-io/validate-action requires being able to validate Flows from OSS CLI against a remote EE instance
-    void runForEEInstance() {
-        ByteArrayOutputStream out = new ByteArrayOutputStream();
-        System.setOut(new PrintStream(out));
-
-        try (ApplicationContext ctx = ApplicationContext.builder().deduceEnvironment(false).start()) {
-            String[] args = {
-                "--tenant",
-                "some-ee-tenant",
-                "--local",
-                "src/test/resources/helper/include.yaml"
-            };
-            Integer call = PicocliRunner.call(FlowValidateCommand.class, ctx, args);
-
-            assertThat(call).isZero();
-            assertThat(out.toString()).contains("✓ - io.kestra.cli / include");
-        }
-    }
-
     @Test
     void warning() {
         ByteArrayOutputStream out = new ByteArrayOutputStream();

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

@@ -1,14 +1,15 @@
 package io.kestra.cli.services;
 
+import io.kestra.core.junit.annotations.FlakyTest;
 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 +19,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,10 +58,12 @@ class FileChangedEventListenerTest {
         }
     }
 
-    @RetryingTest(5) // Flaky on CI but always pass locally
+    @FlakyTest
+    @RetryingTest(2)
     void test() throws IOException, TimeoutException {
+        var tenant = TestsUtils.randomTenant(FileChangedEventListenerTest.class.getSimpleName(), "test");
         // remove the flow if it already exists
-        flowRepository.findByIdWithSource(MAIN_TENANT, "io.kestra.tests.watch", "myflow").ifPresent(flow -> flowRepository.delete(flow));
+        flowRepository.findByIdWithSource(tenant, "io.kestra.tests.watch", "myflow").ifPresent(flow -> flowRepository.delete(flow));
 
         // create a basic flow
         String flow = """
@@ -73,14 +76,14 @@ class FileChangedEventListenerTest {
                 message: Hello World! 🚀
             """;
 
-        GenericFlow genericFlow = GenericFlow.fromYaml(MAIN_TENANT, flow);
+        GenericFlow genericFlow = GenericFlow.fromYaml(tenant, flow);
         Files.write(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"), flow.getBytes());
         Await.until(
-            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "myflow").isPresent(),
+            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "myflow").isPresent(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );
-        Flow myflow = flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "myflow").orElseThrow();
+        Flow myflow = flowRepository.findById(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");
@@ -88,16 +91,18 @@ class FileChangedEventListenerTest {
         // delete the flow
         Files.delete(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"));
         Await.until(
-            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "myflow").isEmpty(),
+            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "myflow").isEmpty(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );
     }
 
-    @RetryingTest(5) // Flaky on CI but always pass locally
+    @FlakyTest
+    @RetryingTest(2)
     void testWithPluginDefault() throws IOException, TimeoutException {
+        var tenant = TestsUtils.randomTenant(FileChangedEventListenerTest.class.getName(), "testWithPluginDefault");
         // remove the flow if it already exists
-        flowRepository.findByIdWithSource(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").ifPresent(flow -> flowRepository.delete(flow));
+        flowRepository.findByIdWithSource(tenant, "io.kestra.tests.watch", "pluginDefault").ifPresent(flow -> flowRepository.delete(flow));
 
         // create a flow with plugin default
         String pluginDefault = """
@@ -113,14 +118,14 @@ class FileChangedEventListenerTest {
                 values:
                   message: Hello World!
             """;
-        GenericFlow genericFlow = GenericFlow.fromYaml(MAIN_TENANT, pluginDefault);
+        GenericFlow genericFlow = GenericFlow.fromYaml(tenant, pluginDefault);
         Files.write(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"), pluginDefault.getBytes());
         Await.until(
-            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").isPresent(),
+            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "pluginDefault").isPresent(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );
-        Flow pluginDefaultFlow = flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").orElseThrow();
+        Flow pluginDefaultFlow = flowRepository.findById(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");
@@ -128,7 +133,7 @@ class FileChangedEventListenerTest {
         // delete both files
         Files.delete(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"));
         Await.until(
-            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").isEmpty(),
+            () -> flowRepository.findById(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:1.81"
+    testImplementation "org.bouncycastle:bcpkix-jdk18on"
 
     testImplementation "org.wiremock:wiremock-jetty12"
 }

core/src/main/java/io/kestra/core/app/AppBlockInterface.java

@@ -7,8 +7,6 @@ import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 /**
  * Top-level marker interface for Kestra's plugin of type App.
  */
@@ -20,6 +18,6 @@ public interface AppBlockInterface extends io.kestra.core.models.Plugin {
     )
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     String getType();
 }

core/src/main/java/io/kestra/core/app/AppPluginInterface.java

@@ -7,8 +7,6 @@ import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 /**
  * Top-level marker interface for Kestra's plugin of type App.
  */
@@ -20,6 +18,6 @@ public interface AppPluginInterface extends io.kestra.core.models.Plugin {
     )
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     String getType();
 }

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

@@ -15,7 +15,6 @@ import com.github.victools.jsonschema.generator.impl.DefinitionKey;
 import com.github.victools.jsonschema.generator.naming.DefaultSchemaDefinitionNamingStrategy;
 import com.github.victools.jsonschema.module.jackson.JacksonModule;
 import com.github.victools.jsonschema.module.jackson.JacksonOption;
-import com.github.victools.jsonschema.module.jackson.JsonUnwrappedDefinitionProvider;
 import com.github.victools.jsonschema.module.jakarta.validation.JakartaValidationModule;
 import com.github.victools.jsonschema.module.jakarta.validation.JakartaValidationOption;
 import com.github.victools.jsonschema.module.swagger2.Swagger2Module;
@@ -46,9 +45,6 @@ import io.swagger.v3.oas.annotations.media.Content;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
-import lombok.extern.slf4j.Slf4j;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.lang.reflect.*;
 import java.time.*;
@@ -62,9 +58,7 @@ import static io.kestra.core.docs.AbstractClassDocumentation.required;
 import static io.kestra.core.serializers.JacksonMapper.MAP_TYPE_REFERENCE;
 
 @Singleton
-@Slf4j
 public class JsonSchemaGenerator {
-    
     private static final List<Class<?>> TYPES_RESOLVED_AS_STRING = List.of(Duration.class, LocalTime.class, LocalDate.class, LocalDateTime.class, ZonedDateTime.class, OffsetDateTime.class, OffsetTime.class);
     private static final List<Class<?>> SUBTYPE_RESOLUTION_EXCLUSION_FOR_PLUGIN_SCHEMA = List.of(Task.class, AbstractTrigger.class);
 
@@ -276,22 +270,8 @@ public class JsonSchemaGenerator {
             .with(Option.DEFINITIONS_FOR_ALL_OBJECTS)
             .with(Option.DEFINITION_FOR_MAIN_SCHEMA)
             .with(Option.PLAIN_DEFINITION_KEYS)
-            .with(Option.ALLOF_CLEANUP_AT_THE_END);
-            
-        // HACK: Registered a custom JsonUnwrappedDefinitionProvider prior to the JacksonModule 
-        // to be able to return an CustomDefinition with an empty node when the ResolvedType can't be found.
-        builder.forTypesInGeneral().withCustomDefinitionProvider(new JsonUnwrappedDefinitionProvider(){
-            @Override
-            public CustomDefinition provideCustomSchemaDefinition(ResolvedType javaType, SchemaGenerationContext context) {
-                try {
-                    return super.provideCustomSchemaDefinition(javaType, context);
-                } catch (NoClassDefFoundError e) {
-                    // This error happens when a non-supported plugin type exists in the classpath.
-                    log.debug("Cannot create schema definition for type '{}'. Cause: NoClassDefFoundError", javaType.getTypeName());
-                    return new CustomDefinition(context.getGeneratorConfig().createObjectNode(), true);
-                }
-            }
-        });
+            .with(Option.ALLOF_CLEANUP_AT_THE_END);;
+
         if (!draft7) {
             builder.with(new JacksonModule(JacksonOption.IGNORE_TYPE_INFO_TRANSFORM));
         } else {
@@ -320,7 +300,6 @@ public class JsonSchemaGenerator {
         // inline some type
         builder.forTypesInGeneral()
             .withCustomDefinitionProvider(new CustomDefinitionProviderV2() {
-                
                 @Override
                 public CustomDefinition provideCustomSchemaDefinition(ResolvedType javaType, SchemaGenerationContext context) {
                     if (javaType.isInstanceOf(Map.class) || javaType.isInstanceOf(Enum.class)) {

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

@@ -6,6 +6,7 @@ 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.")
@@ -43,7 +44,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.key() != null)
+            .filter(label -> label.value() != null && !label.value().isEmpty() && label.key() != null && !label.key().isEmpty())
             // 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));
     }
@@ -58,6 +59,7 @@ 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,6 +74,7 @@ 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();
     }
@@ -90,4 +93,14 @@ 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/QueryFilter.java

@@ -254,19 +254,7 @@ 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)
@@ -279,9 +267,6 @@ 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,31 +17,12 @@ 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,
@@ -52,28 +33,13 @@ public class ExecutionUsage {
                 from,
                 to,
                 DateUtils.GroupType.DAY,
-                null,
-                false))
-            .dailyTaskRunsCount(dailyTaskRunsCount)
+                null))
             .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,
@@ -81,10 +47,8 @@ public class ExecutionUsage {
                 null,
                 from,
                 to,
-                DateUtils.GroupType.DAY,
-                false
+                DateUtils.GroupType.DAY
             ))
-            .dailyTaskRunsCount(dailyTaskRunsCount)
             .build();
     }
 }

core/src/main/java/io/kestra/core/models/conditions/Condition.java

@@ -12,8 +12,6 @@ import lombok.experimental.SuperBuilder;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 @io.kestra.core.models.annotations.Plugin
 @SuperBuilder
 @Getter
@@ -22,6 +20,6 @@ import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
 @JsonInclude(JsonInclude.Include.NON_DEFAULT)
 public abstract class Condition implements Plugin, Rethrow.PredicateChecked<ConditionContext, InternalException> {
     @NotNull
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     protected String type;
 }

core/src/main/java/io/kestra/core/models/dashboards/DataFilter.java

@@ -5,8 +5,6 @@ import io.kestra.core.models.annotations.Plugin;
 import io.kestra.core.models.dashboards.filters.AbstractFilter;
 import io.kestra.core.repositories.QueryBuilderInterface;
 import io.kestra.plugin.core.dashboard.data.IData;
-import jakarta.annotation.Nullable;
-import jakarta.validation.Valid;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
@@ -22,8 +20,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 @SuperBuilder(toBuilder = true)
 @Getter
 @NoArgsConstructor
@@ -32,14 +28,12 @@ import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
 public abstract class DataFilter<F extends Enum<F>, C extends ColumnDescriptor<F>> implements io.kestra.core.models.Plugin, IData<F> {
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp = "\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     private String type;
 
     private Map<String, C> columns;
 
     @Setter
-    @Valid
-    @Nullable
     private List<AbstractFilter<F>> where;
 
     private List<OrderBy> orderBy;

core/src/main/java/io/kestra/core/models/dashboards/DataFilterKPI.java

@@ -19,8 +19,6 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 @SuperBuilder(toBuilder = true)
 @Getter
 @NoArgsConstructor
@@ -29,7 +27,7 @@ import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
 public abstract class DataFilterKPI<F extends Enum<F>, C extends ColumnDescriptor<F>> implements io.kestra.core.models.Plugin, IData<F> {
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp = "\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     private String type;
 
     private C columns;

core/src/main/java/io/kestra/core/models/dashboards/charts/Chart.java

@@ -12,8 +12,6 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 @SuperBuilder(toBuilder = true)
 @Getter
 @NoArgsConstructor
@@ -28,7 +26,7 @@ public abstract class Chart<P extends ChartOption> implements io.kestra.core.mod
 
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp = "\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     protected String type;
 
     @Valid

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

@@ -28,7 +28,6 @@ import io.kestra.core.utils.IdUtils;
 import io.kestra.core.utils.ListUtils;
 import io.kestra.core.utils.MapUtils;
 import io.swagger.v3.oas.annotations.Hidden;
-import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.annotation.Nullable;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
@@ -78,12 +77,10 @@ public class Execution implements DeletedInterface, TenantInterface {
 
     @With
     @JsonInclude(JsonInclude.Include.NON_EMPTY)
-    @Schema(implementation = Object.class)
     Map<String, Object> inputs;
 
     @With
     @JsonInclude(JsonInclude.Include.NON_EMPTY)
-    @Schema(implementation = Object.class)
     Map<String, Object> outputs;
 
     @JsonSerialize(using = ListOrMapOfLabelSerializer.class)
@@ -91,7 +88,6 @@ public class Execution implements DeletedInterface, TenantInterface {
     List<Label> labels;
 
     @With
-    @Schema(implementation = Object.class)
     Map<String, Object> variables;
 
     @NotNull
@@ -651,20 +647,18 @@ public class Execution implements DeletedInterface, TenantInterface {
     public boolean hasFailedNoRetry(List<ResolvedTask> resolvedTasks, TaskRun parentTaskRun) {
         return this.findTaskRunByTasks(resolvedTasks, parentTaskRun)
             .stream()
-            // NOTE: we check on isFailed first to avoid the costly shouldBeRetried() method
-            .anyMatch(taskRun -> taskRun.getState().isFailed() && shouldNotBeRetried(resolvedTasks, parentTaskRun, taskRun));
-    }
-
-    private static boolean shouldNotBeRetried(List<ResolvedTask> resolvedTasks, TaskRun parentTaskRun, TaskRun taskRun) {
-        ResolvedTask resolvedTask = resolvedTasks.stream()
-            .filter(t -> t.getTask().getId().equals(taskRun.getTaskId())).findFirst()
-            .orElse(null);
-        if (resolvedTask == null) {
-            log.warn("Can't find task for taskRun '{}' in parentTaskRun '{}'",
-                taskRun.getId(), parentTaskRun.getId());
-            return false;
-        }
-        return !taskRun.shouldBeRetried(resolvedTask.getTask().getRetry());
+            .anyMatch(taskRun -> {
+                ResolvedTask resolvedTask = resolvedTasks.stream()
+                    .filter(t -> t.getTask().getId().equals(taskRun.getTaskId())).findFirst()
+                    .orElse(null);
+                if (resolvedTask == null) {
+                    log.warn("Can't find task for taskRun '{}' in parentTaskRun '{}'",
+                        taskRun.getId(), parentTaskRun.getId());
+                    return false;
+                }
+                return !taskRun.shouldBeRetried(resolvedTask.getTask().getRetry())
+                    && taskRun.getState().isFailed();
+            });
     }
 
     public boolean hasCreated() {
@@ -871,20 +865,18 @@ 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) {
+    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()
+            );
         return new FailedTaskRunWithLog(
-            taskRun
-                .withAttempts(
-                    Stream
-                        .concat(
-                            taskRun.getAttempts().stream().limit(taskRun.getAttempts().size() - 1),
-                            Stream.of(lastAttempt
-                                .withState(State.Type.FAILED))
-                        )
-                        .toList()
-                )
-                .withState(State.Type.FAILED),
+            failed.getState().isFailed() ? failed : failed.withState(State.Type.FAILED),
             RunContextLogger.logEntries(loggingEventFromException(e), LogEntry.of(taskRun, kind))
         );
     }
@@ -942,15 +934,7 @@ public class Execution implements DeletedInterface, TenantInterface {
                 for (TaskRun current : taskRuns) {
                     if (!MapUtils.isEmpty(current.getOutputs())) {
                         if (current.getIteration() != null) {
-                            Map<String, Object> merged = MapUtils.merge(taskOutputs, outputs(current, byIds));
-                            // If one of two of the map is null in the merge() method, we just return the other
-                            // And if the not null map is a Variables (= read only), we cast it back to a simple
-                            // hashmap to avoid taskOutputs becoming read-only
-                            // i.e this happen in nested loopUntil tasks
-                            if (merged instanceof Variables) {
-                                merged = new HashMap<>(merged);
-                            }
-                            taskOutputs = merged;
+                            taskOutputs = MapUtils.merge(taskOutputs, outputs(current, byIds));
                         } else {
                             taskOutputs.putAll(outputs(current, byIds));
                         }

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

@@ -10,7 +10,6 @@ import io.swagger.v3.oas.annotations.Hidden;
 import jakarta.annotation.Nullable;
 import lombok.Builder;
 import lombok.Value;
-import org.apache.commons.lang3.StringUtils;
 import org.slf4j.event.Level;
 
 import jakarta.validation.constraints.NotNull;
@@ -121,16 +120,6 @@ public class LogEntry implements DeletedInterface, TenantInterface {
         return logEntry.getTimestamp().toString() + " " + logEntry.getLevel() + " " + logEntry.getMessage();
     }
 
-    public static String toPrettyString(LogEntry logEntry, Integer maxMessageSize) {
-        String message;
-        if (maxMessageSize != null && maxMessageSize > 0) {
-            message = StringUtils.truncate(logEntry.getMessage(), maxMessageSize);
-        } else {
-            message = logEntry.getMessage();
-        }
-        return logEntry.getTimestamp().toString() + " " + logEntry.getLevel() + " " + message;
-    }
-
     public Map<String, String> toMap() {
         return Stream
             .of(

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

@@ -3,13 +3,10 @@ package io.kestra.core.models.executions;
 import com.fasterxml.jackson.annotation.JsonInclude;
 import io.kestra.core.models.TenantInterface;
 import io.kestra.core.models.flows.State;
-import io.kestra.core.models.tasks.FlowableTask;
 import io.kestra.core.models.tasks.ResolvedTask;
-import io.kestra.core.models.tasks.Task;
 import io.kestra.core.models.tasks.retrys.AbstractRetry;
 import io.kestra.core.utils.IdUtils;
 import io.swagger.v3.oas.annotations.Hidden;
-import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.annotation.Nullable;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
@@ -55,8 +52,6 @@ public class TaskRun implements TenantInterface {
 
     @With
     @JsonInclude(JsonInclude.Include.ALWAYS)
-    @Nullable
-    @Schema(implementation = Object.class)
     Variables outputs;
 
     @NotNull
@@ -69,6 +64,7 @@ public class TaskRun implements TenantInterface {
     Boolean dynamic;
 
     // Set it to true to force execution even if the execution is killed
+    @Nullable
     @With
     Boolean forceExecution;
 
@@ -221,7 +217,7 @@ public class TaskRun implements TenantInterface {
     public boolean isSame(TaskRun taskRun) {
         return this.getId().equals(taskRun.getId()) &&
             ((this.getValue() == null && taskRun.getValue() == null) || (this.getValue() != null && this.getValue().equals(taskRun.getValue()))) &&
-            ((this.getIteration() == null && taskRun.getIteration() == null) || (this.getIteration() != null && this.getIteration().equals(taskRun.getIteration())));
+            ((this.getIteration() == null && taskRun.getIteration() == null) || (this.getIteration() != null && this.getIteration().equals(taskRun.getIteration()))) ;
     }
 
     public String toString(boolean pretty) {
@@ -253,7 +249,7 @@ public class TaskRun implements TenantInterface {
      * This method is used when the retry is apply on a task
      * but the retry type is NEW_EXECUTION
      *
-     * @param retry     Contains the retry configuration
+     * @param retry Contains the retry configuration
      * @param execution Contains the attempt number and original creation date
      * @return The next retry date, null if maxAttempt || maxDuration is reached
      */
@@ -274,7 +270,6 @@ public class TaskRun implements TenantInterface {
 
     /**
      * This method is used when the Retry definition comes from the flow
-     *
      * @param retry The retry configuration
      * @return The next retry date, null if maxAttempt || maxDuration is reached
      */
@@ -301,7 +296,7 @@ public class TaskRun implements TenantInterface {
     }
 
     public TaskRun incrementIteration() {
-        int iteration = this.iteration == null ? 1 : this.iteration;
+        int iteration = this.iteration == null ? 0 : this.iteration;
         return this.toBuilder()
             .iteration(iteration + 1)
             .build();
@@ -314,11 +309,4 @@ public class TaskRun implements TenantInterface {
             .build();
     }
 
-    public TaskRun addAttempt(TaskRunAttempt attempt) {
-        if (this.attempts == null) {
-            this.attempts = new ArrayList<>();
-        }
-        this.attempts.add(attempt);
-        return this;
-    }
 }

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

@@ -61,22 +61,18 @@ public abstract class AbstractFlow implements FlowInterface {
     @JsonSerialize(using = ListOrMapOfLabelSerializer.class)
     @JsonDeserialize(using = ListOrMapOfLabelDeserializer.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
-        }
+            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;
 
-    @Schema(
-        type = "object",
-        additionalProperties = Schema.AdditionalPropertiesValue.FALSE
-    )
+    @Schema(additionalProperties = Schema.AdditionalPropertiesValue.TRUE)
     Map<String, Object> variables;
 
-
     @Valid
     private WorkerGroup workerGroup;
 

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

@@ -24,8 +24,4 @@ public class Concurrency {
     public enum Behavior {
         QUEUE, CANCEL, FAIL;
     }
-
-    public static boolean possibleTransitions(State.Type type) {
-        return type.equals(State.Type.CANCELLED) || type.equals(State.Type.FAILED);
-    }
 }

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

@@ -61,11 +61,6 @@ public class Flow extends AbstractFlow implements HasUID {
             }
         });
 
-
-    @Schema(
-        type = "object",
-        additionalProperties = Schema.AdditionalPropertiesValue.FALSE
-    )
     Map<String, Object> variables;
 
     @Valid

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

@@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonSubTypes;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import io.kestra.core.models.flows.input.*;
 import io.kestra.core.models.property.Property;
+import io.kestra.core.runners.RunContext;
 import io.micronaut.core.annotation.Introspected;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.ConstraintViolationException;
@@ -17,6 +18,8 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 
+import java.util.function.Function;
+
 @SuppressWarnings("deprecation")
 @SuperBuilder
 @Getter

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

@@ -1,7 +1,6 @@
 package io.kestra.core.models.flows;
 
 import io.micronaut.core.annotation.Introspected;
-import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.Valid;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
@@ -34,12 +33,6 @@ public class Output implements Data {
      * The output value. Can be a dynamic expression.
      */
     @NotNull
-    @Schema(
-        oneOf = {
-            Object.class,
-            String.class
-        }
-    )
     Object value;
 
     /**

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

@@ -2,7 +2,6 @@ package io.kestra.core.models.flows;
 
 import io.kestra.core.validations.PluginDefaultValidation;
 import io.micronaut.core.annotation.Introspected;
-import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotNull;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -22,10 +21,6 @@ public class PluginDefault {
     @Builder.Default
     private final boolean forced = false;
 
-    @Schema(
-        type = "object",
-        additionalProperties = Schema.AdditionalPropertiesValue.FALSE
-    )
     private final Map<String, Object> values;
 }
 

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

@@ -86,11 +86,10 @@ public class State {
 
     @JsonProperty(access = JsonProperty.Access.READ_ONLY)
     public Duration getDuration() {
-        if (this.getEndDate().isPresent()) {
+        if(this.getEndDate().isPresent()){
             return Duration.between(this.getStartDate(), this.getEndDate().get());
         } else {
-//            return Duration.between(this.getStartDate(), Instant.now()); TODO improve
-            return null;
+            return Duration.between(this.getStartDate(), Instant.now());
         }
     }
 

core/src/main/java/io/kestra/core/models/property/Property.java

@@ -12,7 +12,6 @@ import com.google.common.annotations.VisibleForTesting;
 import io.kestra.core.exceptions.IllegalVariableEvaluationException;
 import io.kestra.core.runners.RunContext;
 import io.kestra.core.serializers.JacksonMapper;
-import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotNull;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -35,13 +34,8 @@ import static io.kestra.core.utils.Rethrow.throwFunction;
 @JsonDeserialize(using = Property.PropertyDeserializer.class)
 @JsonSerialize(using = Property.PropertySerializer.class)
 @Builder
+@NoArgsConstructor
 @AllArgsConstructor(access = AccessLevel.PACKAGE)
-@Schema(
-    oneOf = {
-        Object.class,
-        String.class
-    }
-)
 public class Property<T> {
     // By default, durations are stored as numbers.
     // We cannot change that globally, as in JDBC/Elastic 'execution.state.duration' must be a number to be able to aggregate them.
@@ -50,7 +44,6 @@ public class Property<T> {
         .copy()
         .configure(SerializationFeature.WRITE_DURATIONS_AS_TIMESTAMPS, false);
 
-    private final boolean skipCache;
     private String expression;
     private T value;
 
@@ -60,23 +53,13 @@ public class Property<T> {
     @Deprecated
     // Note: when not used, this constructor would not be deleted but made private so it can only be used by ofExpression(String) and the deserializer
     public Property(String expression) {
-        this(expression, false);
-    }
-
-    private Property(String expression, boolean skipCache) {
         this.expression = expression;
-        this.skipCache = skipCache;
     }
 
-    /**
-     * @deprecated use {@link #ofValue(Object)} instead.
-     */
     @VisibleForTesting
-    @Deprecated
     public Property(Map<?, ?> map) {
         try {
             expression = MAPPER.writeValueAsString(map);
-            this.skipCache = false;
         } catch (JsonProcessingException e) {
             throw new IllegalArgumentException(e);
         }
@@ -85,10 +68,13 @@ public class Property<T> {
     String getExpression() {
         return expression;
     }
-
+    
     /**
      * Returns a new {@link Property} with no cached rendered value,
      * so that the next render will evaluate its original Pebble expression.
+     * <p>
+     * The returned property will still cache its rendered result.
+     * To re-evaluate on a subsequent render, call {@code skipCache()} again.
      *
      * @return a new {@link Property} without a pre-rendered value
      */
@@ -98,9 +84,9 @@ public class Property<T> {
 
     /**
      * Build a new Property object with a value already set.<br>
-     * <p>
+     *
      * A property build with this method will always return the value passed at build time, no rendering will be done.
-     * <p>
+     *
      * Use {@link #ofExpression(String)} to build a property with a Pebble expression instead.
      */
     public static <V> Property<V> ofValue(V value) {
@@ -140,22 +126,21 @@ public class Property<T> {
 
     /**
      * Build a new Property object with a Pebble expression.<br>
-     * This property object will not cache its rendered value.
-     * <p>
+     *
      * Use {@link #ofValue(Object)} to build a property with a value instead.
      */
     public static <V> Property<V> ofExpression(@NotNull String expression) {
         Objects.requireNonNull(expression, "'expression' is required");
-        if (!expression.contains("{")) {
+        if(!expression.contains("{")) {
             throw new IllegalArgumentException("'expression' must be a valid Pebble expression");
         }
 
-        return new Property<>(expression, true);
+        return new Property<>(expression);
     }
 
     /**
-     * Render a property, then convert it to its target type.<br>
-     * <p>
+     * Render a property then convert it to its target type.<br>
+     *
      * This method is designed to be used only by the {@link io.kestra.core.runners.RunContextProperty}.
      *
      * @see io.kestra.core.runners.RunContextProperty#as(Class)
@@ -166,14 +151,14 @@ public class Property<T> {
 
     /**
      * Render a property with additional variables, then convert it to its target type.<br>
-     * <p>
+     *
      * This method is designed to be used only by the {@link io.kestra.core.runners.RunContextProperty}.
      *
      * @see io.kestra.core.runners.RunContextProperty#as(Class, Map)
      */
     public static <T> T as(Property<T> property, PropertyContext context, Class<T> clazz, Map<String, Object> variables) throws IllegalVariableEvaluationException {
-        if (property.skipCache || property.value == null) {
-            String rendered = context.render(property.expression, variables);
+        if (property.value == null) {
+            String rendered =  context.render(property.expression, variables);
             property.value = MAPPER.convertValue(rendered, clazz);
         }
 
@@ -182,7 +167,7 @@ public class Property<T> {
 
     /**
      * Render a property then convert it as a list of target type.<br>
-     * <p>
+     *
      * This method is designed to be used only by the {@link io.kestra.core.runners.RunContextProperty}.
      *
      * @see io.kestra.core.runners.RunContextProperty#asList(Class)
@@ -193,14 +178,14 @@ public class Property<T> {
 
     /**
      * Render a property with additional variables, then convert it as a list of target type.<br>
-     * <p>
+     *
      * This method is designed to be used only by the {@link io.kestra.core.runners.RunContextProperty}.
      *
      * @see io.kestra.core.runners.RunContextProperty#asList(Class, Map)
      */
     @SuppressWarnings("unchecked")
     public static <T, I> T asList(Property<T> property, PropertyContext context, Class<I> itemClazz, Map<String, Object> variables) throws IllegalVariableEvaluationException {
-        if (property.skipCache || property.value == null) {
+        if (property.value == null) {
             JavaType type = MAPPER.getTypeFactory().constructCollectionLikeType(List.class, itemClazz);
             try {
                 String trimmedExpression = property.expression.trim();
@@ -233,26 +218,26 @@ public class Property<T> {
 
     /**
      * Render a property then convert it as a map of target types.<br>
-     * <p>
+     *
      * This method is designed to be used only by the {@link io.kestra.core.runners.RunContextProperty}.
      *
      * @see io.kestra.core.runners.RunContextProperty#asMap(Class, Class)
      */
-    public static <T, K, V> T asMap(Property<T> property, RunContext runContext, Class<K> keyClass, Class<V> valueClass) throws IllegalVariableEvaluationException {
+    public static <T, K,V> T asMap(Property<T> property, RunContext runContext, Class<K> keyClass, Class<V> valueClass) throws IllegalVariableEvaluationException {
         return asMap(property, runContext, keyClass, valueClass, Map.of());
     }
 
     /**
      * Render a property with additional variables, then convert it as a map of target types.<br>
-     * <p>
+     *
      * This method is safe to be used as many times as you want as the rendering and conversion will be cached.
      * Warning, due to the caching mechanism, this method is not thread-safe.
      *
      * @see io.kestra.core.runners.RunContextProperty#asMap(Class, Class, Map)
      */
     @SuppressWarnings({"rawtypes", "unchecked"})
-    public static <T, K, V> T asMap(Property<T> property, RunContext runContext, Class<K> keyClass, Class<V> valueClass, Map<String, Object> variables) throws IllegalVariableEvaluationException {
-        if (property.skipCache || property.value == null) {
+    public static <T, K,V> T asMap(Property<T> property, RunContext runContext, Class<K> keyClass, Class<V> valueClass, Map<String, Object> variables) throws IllegalVariableEvaluationException {
+        if (property.value == null) {
             JavaType targetMapType = MAPPER.getTypeFactory().constructMapType(Map.class, keyClass, valueClass);
 
             try {

core/src/main/java/io/kestra/core/models/tasks/ResolvedTask.java

@@ -30,7 +30,7 @@ public class ResolvedTask {
 
     public NextTaskRun toNextTaskRunIncrementIteration(Execution execution, Integer iteration) {
         return new NextTaskRun(
-            TaskRun.of(execution, this).withIteration(iteration != null ? iteration : 1),
+            TaskRun.of(execution, this).withIteration(iteration != null ? iteration : 0),
             this.getTask()
         );
     }

core/src/main/java/io/kestra/core/models/tasks/TaskInterface.java

@@ -8,8 +8,6 @@ import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 @JsonInclude(JsonInclude.Include.NON_DEFAULT)
 public interface TaskInterface extends Plugin, PluginVersioning {
     @NotNull
@@ -19,7 +17,7 @@ public interface TaskInterface extends Plugin, PluginVersioning {
 
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     @Schema(title = "The class name of this task.")
     String getType();
 }

core/src/main/java/io/kestra/core/models/tasks/logs/LogExporter.java

@@ -11,8 +11,6 @@ import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 import reactor.core.publisher.Flux;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 @Plugin
 @SuperBuilder(toBuilder = true)
 @Getter
@@ -24,7 +22,7 @@ public abstract class LogExporter<T extends Output>  implements io.kestra.core.m
     protected String id;
 
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     protected String type;
 
     public abstract T sendLogs(RunContext runContext, Flux<LogRecord> logRecords) throws Exception;

core/src/main/java/io/kestra/core/models/tasks/logs/LogRecordMapper.java

@@ -8,16 +8,12 @@ public final class LogRecordMapper {
     private LogRecordMapper(){}
 
     public static LogRecord mapToLogRecord(LogEntry log) {
-        return mapToLogRecord(log, null);
-    }
-
-    public static LogRecord mapToLogRecord(LogEntry log, Integer maxMessageSize) {
         return LogRecord.builder()
             .resource("Kestra")
             .timestampEpochNanos(instantInNanos(log.getTimestamp()))
             .severity(log.getLevel().name())
             .attributes(log.toLogMap())
-            .bodyValue(LogEntry.toPrettyString(log, maxMessageSize))
+            .bodyValue(LogEntry.toPrettyString(log))
             .build();
     }
 

core/src/main/java/io/kestra/core/models/tasks/runners/RemoteRunnerInterface.java

@@ -1,11 +1,3 @@
 package io.kestra.core.models.tasks.runners;
 
-import io.kestra.core.models.property.Property;
-import io.swagger.v3.oas.annotations.media.Schema;
-
-public interface RemoteRunnerInterface {
-    @Schema(
-        title = "Whether to synchronize working directory from remote runner back to local one after run."
-    )
-    Property<Boolean> getSyncWorkingDirectory();
-}
+public interface RemoteRunnerInterface {}

core/src/main/java/io/kestra/core/models/tasks/runners/TaskCommands.java

@@ -30,10 +30,6 @@ public interface TaskCommands {
 
     Map<String, Object> getAdditionalVars();
 
-    default String outputDirectoryName() {
-        return this.getWorkingDirectory().relativize(this.getOutputDirectory()).toString();
-    }
-
     Path getWorkingDirectory();
 
     Path getOutputDirectory();

core/src/main/java/io/kestra/core/models/tasks/runners/TaskRunner.java

@@ -7,6 +7,7 @@ import io.kestra.core.models.Plugin;
 import io.kestra.core.models.PluginVersioning;
 import io.kestra.core.models.WorkerJobLifecycle;
 import io.kestra.core.models.annotations.PluginProperty;
+import io.kestra.core.models.property.Property;
 import io.kestra.core.runners.RunContext;
 import io.kestra.plugin.core.runner.Process;
 import jakarta.validation.constraints.NotBlank;
@@ -18,14 +19,13 @@ import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 import org.apache.commons.lang3.SystemUtils;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.io.IOException;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Stream;
 
 import static io.kestra.core.utils.WindowsUtils.windowsToUnixPath;
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
 
 /**
  * Base class for all task runners.
@@ -37,7 +37,7 @@ import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
 @JsonInclude(JsonInclude.Include.NON_DEFAULT)
 public abstract class TaskRunner<T extends TaskRunnerDetailResult> implements Plugin, PluginVersioning, WorkerJobLifecycle {
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     protected String type;
 
     @PluginProperty(hidden = true, group = PluginProperty.CORE_GROUP)

core/src/main/java/io/kestra/core/models/triggers/AbstractTrigger.java

@@ -47,9 +47,9 @@ abstract public class AbstractTrigger implements TriggerInterface {
     @Valid
     protected List<@Valid @NotNull Condition> conditions;
 
+    @NotNull
     @Builder.Default
     @PluginProperty(hidden = true, group = PluginProperty.CORE_GROUP)
-    @Schema(defaultValue = "false")
     private boolean disabled = false;
 
     @Valid

core/src/main/java/io/kestra/core/models/triggers/TriggerContext.java

@@ -4,7 +4,6 @@ import io.kestra.core.models.flows.State;
 import io.kestra.core.utils.IdUtils;
 import io.micronaut.core.annotation.Introspected;
 import io.micronaut.core.annotation.Nullable;
-import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
 import lombok.Getter;
@@ -47,7 +46,6 @@ public class TriggerContext {
     @Nullable
     private List<State.Type> stopAfter;
 
-    @Schema(defaultValue = "false")
     private Boolean disabled = Boolean.FALSE;
 
     protected TriggerContext(TriggerContextBuilder<?, ?> b) {

core/src/main/java/io/kestra/core/models/triggers/TriggerInterface.java

@@ -7,7 +7,6 @@ import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
 
 public interface TriggerInterface extends Plugin, PluginVersioning {
     @NotNull
@@ -18,7 +17,7 @@ public interface TriggerInterface extends Plugin, PluginVersioning {
 
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     @Schema(title = "The class name for this current trigger.")
     String getType();
 

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

@@ -8,8 +8,6 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 @io.kestra.core.models.annotations.Plugin
 @SuperBuilder(toBuilder = true)
 @Getter
@@ -17,6 +15,6 @@ import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
 public abstract class AdditionalPlugin implements Plugin {
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     protected String type;
 }

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

@@ -56,7 +56,7 @@ public class DefaultPluginRegistry implements PluginRegistry {
      *
      * @return the {@link DefaultPluginRegistry}.
      */
-    public static DefaultPluginRegistry getOrCreate() {
+    public synchronized 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 void init() {
+    protected synchronized 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/PluginArtifact.java

@@ -1,6 +1,5 @@
 package io.kestra.core.plugins;
 
-import com.fasterxml.jackson.annotation.JsonIgnore;
 import lombok.Builder;
 
 import java.io.File;
@@ -34,7 +33,7 @@ public record PluginArtifact(
     String version,
     URI uri
 ) implements Comparable<PluginArtifact> {
-    
+
     private static final Pattern ARTIFACT_PATTERN = Pattern.compile(
         "([^: ]+):([^: ]+)(:([^: ]*)(:([^: ]+))?)?:([^: ]+)"
     );
@@ -43,8 +42,7 @@ public record PluginArtifact(
     );
 
     public static final String JAR_EXTENSION = "jar";
-    public static final String KESTRA_GROUP_ID = "io.kestra";
-    
+
     /**
      * Static helper method for constructing a new {@link PluginArtifact} from a JAR file.
      *
@@ -137,11 +135,6 @@ public record PluginArtifact(
     public String toString() {
         return toCoordinates();
     }
-    
-    @JsonIgnore
-    public boolean isOfficial() {
-        return groupId.startsWith(KESTRA_GROUP_ID);
-    }
 
     public String toCoordinates() {
         return Stream.of(groupId, artifactId, extension, classifier, version)

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

@@ -1,13 +1,9 @@
 package io.kestra.core.plugins;
 
-import io.kestra.core.contexts.KestraContext;
-import io.kestra.core.utils.ListUtils;
-import io.kestra.core.utils.Version;
 import io.micronaut.core.type.Argument;
 import io.micronaut.http.HttpMethod;
 import io.micronaut.http.HttpRequest;
 import io.micronaut.http.HttpResponse;
-import io.micronaut.http.MutableHttpRequest;
 import io.micronaut.http.client.HttpClient;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -19,12 +15,9 @@ import java.util.Base64;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.Function;
-import java.util.stream.Collectors;
 
 /**
  * Services for retrieving available plugin artifacts for Kestra.
@@ -46,8 +39,6 @@ public class PluginCatalogService {
 
     private final boolean icons;
     private final boolean oss;
-    
-    private final Version currentStableVersion;
 
     /**
      * Creates a new {@link PluginCatalogService} instance.
@@ -62,55 +53,11 @@ public class PluginCatalogService {
         this.httpClient = httpClient;
         this.icons = icons;
         this.oss = communityOnly;
-        
-        Version version = Version.of(KestraContext.getContext().getVersion());
-        this.currentStableVersion = new Version(version.majorVersion(), version.minorVersion(), version.patchVersion(), null);
-        
+
         // Immediately trigger an async load of plugin artifacts.
         this.isLoaded.set(true);
         this.plugins = CompletableFuture.supplyAsync(this::load);
     }
-    
-    /**
-     * Resolves the version for the given artifacts.
-     *
-     * @param artifacts The list of artifacts to resolve.
-     * @return The list of results.
-     */
-    public List<PluginResolutionResult> resolveVersions(List<PluginArtifact> artifacts) {
-        if (ListUtils.isEmpty(artifacts)) {
-            return List.of();
-        }
-        
-        final Map<String, ApiPluginArtifact> pluginsByGroupAndArtifactId = getAllCompatiblePlugins().stream()
-            .collect(Collectors.toMap(it -> it.groupId() + ":" + it.artifactId(), Function.identity()));
-        
-        return artifacts.stream().map(it -> {
-            // Get all compatible versions for current artifact
-            List<String> versions = Optional
-                .ofNullable(pluginsByGroupAndArtifactId.get(it.groupId() + ":" + it.artifactId()))
-                .map(ApiPluginArtifact::versions)
-                .orElse(List.of());
-            
-            // Try to resolve the version
-            String resolvedVersion = null;
-            if (!versions.isEmpty()) {
-                if (it.version().equalsIgnoreCase("LATEST")) {
-                    resolvedVersion = versions.getFirst();
-                } else {
-                    resolvedVersion = versions.contains(it.version()) ? it.version() : null;
-                }
-            }
-
-            // Build the PluginResolutionResult
-            return new PluginResolutionResult(
-                it,
-                resolvedVersion,
-                versions,
-                resolvedVersion != null
-            );
-        }).toList();
-    }
 
     public synchronized List<PluginManifest> get() {
         try {
@@ -193,27 +140,7 @@ public class PluginCatalogService {
             isLoaded.set(false);
         }
     }
-    
-    private List<ApiPluginArtifact> getAllCompatiblePlugins() {
 
-        MutableHttpRequest<Object> request = HttpRequest.create(
-            HttpMethod.GET, 
-            "/v1/plugins/artifacts/core-compatibility/" + currentStableVersion
-        );
-        if (oss) {
-            request.getParameters().add("license", "OPENSOURCE");
-        }
-        try {
-            return httpClient
-                .toBlocking()
-                .exchange(request, Argument.listOf(ApiPluginArtifact.class))
-                .body();
-        } catch (Exception e) {
-            log.debug("Failed to retrieve available plugins from Kestra API. Cause: ", e);
-            return List.of();
-        }
-    }
-    
     public record PluginManifest(
         String title,
         String icon,
@@ -226,11 +153,4 @@ public class PluginCatalogService {
             return groupId + ":" + artifactId + ":LATEST";
         }
     }
-    
-    public record ApiPluginArtifact(
-        String groupId,
-        String artifactId,
-        String license,
-        List<String> versions
-    ) {}
 }

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

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

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

@@ -25,8 +25,6 @@ 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);
     }
@@ -96,12 +94,6 @@ 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);
@@ -114,8 +106,7 @@ public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Ex
         @Nullable String flowId,
         @Nullable ZonedDateTime startDate,
         @Nullable ZonedDateTime endDate,
-        @Nullable DateUtils.GroupType groupBy,
-        boolean isTaskRun
+        @Nullable DateUtils.GroupType groupBy
     );
 
     List<DailyExecutionStatistics> dailyStatistics(
@@ -127,8 +118,7 @@ public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Ex
         @Nullable ZonedDateTime startDate,
         @Nullable ZonedDateTime endDate,
         @Nullable DateUtils.GroupType groupBy,
-        List<State.Type> state,
-        boolean isTaskRun
+        List<State.Type> state
     );
 
     @Getter

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

@@ -4,6 +4,7 @@ import io.kestra.core.models.QueryFilter;
 import io.kestra.core.models.SearchResult;
 import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.flows.*;
+import io.kestra.plugin.core.dashboard.data.Flows;
 import io.micronaut.data.model.Pageable;
 import jakarta.annotation.Nullable;
 import jakarta.validation.ConstraintViolationException;
@@ -11,7 +12,7 @@ import jakarta.validation.ConstraintViolationException;
 import java.util.List;
 import java.util.Optional;
 
-public interface FlowRepositoryInterface {
+public interface FlowRepositoryInterface extends QueryBuilderInterface<Flows.Fields> {
 
     Optional<Flow> findById(String tenantId, String namespace, String id, Optional<Integer> revision, Boolean allowDeleted);
 
@@ -25,8 +26,8 @@ public interface FlowRepositoryInterface {
      * Used only if result is used internally and not exposed to the user.
      * It is useful when we want to restart/resume a flow.
      */
-    default FlowWithSource findByExecutionWithoutAcl(Execution execution) {
-        Optional<FlowWithSource> find = this.findByIdWithSourceWithoutAcl(
+    default Flow findByExecutionWithoutAcl(Execution execution) {
+        Optional<Flow> find = this.findByIdWithoutAcl(
             execution.getTenantId(),
             execution.getNamespace(),
             execution.getFlowId(),
@@ -162,4 +163,6 @@ public interface FlowRepositoryInterface {
     FlowWithSource update(GenericFlow flow, FlowInterface previous) throws ConstraintViolationException;
 
     FlowWithSource delete(FlowInterface flow);
+
+    Boolean existAnyNoAcl(String tenantId);
 }

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

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

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

@@ -1,31 +0,0 @@
-package io.kestra.core.runners;
-
-import io.kestra.core.models.HasUID;
-import io.kestra.core.utils.IdUtils;
-import jakarta.validation.constraints.NotNull;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Value;
-import lombok.With;
-
-@Value
-@AllArgsConstructor
-@Builder
-public class ConcurrencyLimit implements HasUID {
-    @NotNull
-    String tenantId;
-
-    @NotNull
-    String namespace;
-
-    @NotNull
-    String flowId;
-
-    @With
-    Integer running;
-
-    @Override
-    public String uid() {
-        return IdUtils.fromPartsAndSeparator('|', this.tenantId, this.namespace, this.flowId);
-    }
-}

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

@@ -5,10 +5,7 @@ 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.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.flows.*;
 import io.kestra.core.models.property.Property;
 import io.kestra.core.models.tasks.ExecutableTask;
 import io.kestra.core.models.tasks.Task;
@@ -29,6 +26,7 @@ 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;
@@ -56,10 +54,12 @@ public final class ExecutableUtils {
     }
 
     public static SubflowExecutionResult subflowExecutionResult(TaskRun parentTaskrun, Execution execution) {
+        List<TaskRunAttempt> attempts = parentTaskrun.getAttempts() == null ? new ArrayList<>() : new ArrayList<>(parentTaskrun.getAttempts());
+        attempts.add(TaskRunAttempt.builder().state(parentTaskrun.getState()).build());
         return SubflowExecutionResult.builder()
             .executionId(execution.getId())
             .state(parentTaskrun.getState().getCurrent())
-            .parentTaskRun(parentTaskrun.addAttempt(TaskRunAttempt.builder().state(parentTaskrun.getState()).build()))
+            .parentTaskRun(parentTaskrun.withAttempts(attempts))
             .build();
     }
 
@@ -151,14 +151,22 @@ public final class ExecutableUtils {
                     currentFlow.getNamespace(),
                     currentFlow.getId()
                 )
-                .orElseThrow(() -> new IllegalStateException("Unable to find flow '" + subflowNamespace + "'.'" + subflowId + "' with revision '" + subflowRevision.orElse(0) + "'"));
+                .orElseThrow(() -> {
+                    String msg = "Unable to find flow '" + subflowNamespace + "'.'" + subflowId + "' with revision '" + subflowRevision.orElse(0) + "'";
+                    runContext.logger().error(msg);
+                    return new IllegalStateException(msg);
+                });
 
             if (flow.isDisabled()) {
-                throw new IllegalStateException("Cannot execute a flow which is disabled");
+                String msg = "Cannot execute a flow which is disabled";
+                runContext.logger().error(msg);
+                throw new IllegalStateException(msg);
             }
 
             if (flow instanceof FlowWithException fwe) {
-                throw new IllegalStateException("Cannot execute an invalid flow: " + fwe.getException());
+                String msg = "Cannot execute an invalid flow: " + fwe.getException();
+                runContext.logger().error(msg);
+                throw new IllegalStateException(msg);
             }
 
             List<Label> newLabels = inheritLabels ? new ArrayList<>(filterLabels(currentExecution.getLabels(), flow)) : new ArrayList<>(systemLabels(currentExecution));
@@ -199,7 +207,20 @@ 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/FilesService.java

@@ -82,7 +82,6 @@ public abstract class FilesService {
     }
 
     private static String resolveUniqueNameForFile(final Path path) {
-        String filename = path.getFileName().toString().replace(' ', '+');
-        return IdUtils.from(path.toString()) + "-" + filename;
+        return IdUtils.from(path.toString()) + "-" + path.toFile().getName();
     }
 }

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

@@ -1,6 +1,7 @@
 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;
@@ -48,15 +49,7 @@ import java.time.Duration;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalTime;
-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.*;
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.regex.Matcher;
@@ -72,28 +65,31 @@ 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,
@@ -101,11 +97,10 @@ 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, false));
+
+        return readData(inputs, execution, data, false).map(inputData -> resolveInputs(inputs, flow, execution, inputData));
     }
-    
+
     /**
      * Reads all the inputs of a given execution of a flow.
      *
@@ -119,7 +114,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.
      *
@@ -134,7 +129,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())
@@ -217,7 +212,7 @@ public class FlowInputOutput {
         final Execution execution,
         final Map<String, ?> data
     ) {
-        Map<String, Object> resolved = this.resolveInputs(inputs, flow, execution, data, true)
+        Map<String, Object> resolved = this.resolveInputs(inputs, flow, execution, data)
             .stream()
             .filter(InputAndValue::enabled)
             .map(it -> {
@@ -228,9 +223,22 @@ 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.
      *
@@ -239,21 +247,12 @@ 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();
@@ -263,7 +262,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, decryptSecrets));
+        resolvableInputMap.values().forEach(input -> resolveInputValue(input, flow, execution, resolvableInputMap));
 
         return resolvableInputMap.values().stream().map(ResolvableInput::get).toList();
     }
@@ -273,8 +272,7 @@ public class FlowInputOutput {
         final @NotNull ResolvableInput resolvable,
         final FlowInterface flow,
         final @NotNull Execution execution,
-        final @NotNull Map<String, ResolvableInput> inputs,
-        final boolean decryptSecrets) {
+        final @NotNull Map<String, ResolvableInput> inputs) {
 
         // return immediately if the input is already resolved
         if (resolvable.isResolved()) return resolvable.get();
@@ -282,10 +280,9 @@ public class FlowInputOutput {
         Input<?> input = resolvable.get().input();
 
         try {
-            // Resolve all input dependencies and check whether input is enabled
-            // Note: Secrets are always decrypted here because they can be part of expressions used to render inputs such as SELECT & MULTI_SELECT.
-            final Map<String, InputAndValue> dependencies = resolveAllDependentInputs(input, flow, execution, inputs, true);
-            final RunContext runContext = buildRunContextForExecutionAndInputs(flow, execution, dependencies, true);
+            //  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);
 
             boolean isInputEnabled = dependencies.isEmpty() || dependencies.values().stream().allMatch(InputAndValue::enabled);
 
@@ -320,16 +317,16 @@ public class FlowInputOutput {
                 }
             });
             resolvable.setInput(input);
-            
+
+
             Object value = resolvable.get().value();
-            
+
             // resolve default if needed
             if (value == null && input.getDefaults() != null) {
-                RunContext runContextForDefault = decryptSecrets ? runContext : buildRunContextForExecutionAndInputs(flow, execution, dependencies, false);
-                value = resolveDefaultValue(input, runContextForDefault);
+                value = resolveDefaultValue(input, runContext);
                 resolvable.isDefault(true);
             }
-            
+
             // validate and parse input value
             if (value == null) {
                 if (input.getRequired()) {
@@ -358,7 +355,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);
@@ -375,7 +372,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);
@@ -385,7 +382,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, final boolean decryptSecrets) {
+    private RunContext buildRunContextForExecutionAndInputs(final FlowInterface flow, final Execution execution, Map<String, InputAndValue> dependencies) {
         Map<String, Object> flattenInputs = MapUtils.flattenToNestedMap(dependencies.entrySet()
             .stream()
             .collect(HashMap::new, (m, v) -> m.put(v.getKey(), v.getValue().value()), HashMap::putAll)
@@ -399,10 +396,10 @@ public class FlowInputOutput {
                 flattenInputs.put(input.getId(), null);
             }
         }
-        return runContextFactory.of(flow, execution, vars -> vars.withInputs(flattenInputs), decryptSecrets);
+        return runContextFactory.of(flow, execution, vars -> vars.withInputs(flattenInputs));
     }
 
-    private Map<String, InputAndValue> resolveAllDependentInputs(final Input<?> input, final FlowInterface flow, final Execution execution, final Map<String, ResolvableInput> inputs, final boolean decryptSecrets) {
+    private Map<String, InputAndValue> resolveAllDependentInputs(final Input<?> input, final FlowInterface flow, final Execution execution, final Map<String, ResolvableInput> inputs) {
         return Optional.ofNullable(input.getDependsOn())
             .map(DependsOn::inputs)
             .stream()
@@ -410,7 +407,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, decryptSecrets))
+            .map(it -> resolveInputValue(it, flow, execution, inputs))
             .collect(Collectors.toMap(it -> it.input().getId(), Function.identity()));
     }
 
@@ -461,7 +458,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<>(
@@ -538,17 +535,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())) {
@@ -591,9 +588,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/FlowableUtils.java

@@ -11,7 +11,6 @@ import io.kestra.core.models.flows.State;
 import io.kestra.core.models.tasks.ResolvedTask;
 import io.kestra.core.models.tasks.Task;
 import io.kestra.core.serializers.JacksonMapper;
-import io.kestra.core.utils.ListUtils;
 import io.kestra.plugin.core.flow.Dag;
 
 import java.util.*;
@@ -153,35 +152,6 @@ public class FlowableUtils {
         return Collections.emptyList();
     }
 
-    public static Optional<State.Type> resolveSequentialState(
-        Execution execution,
-        List<ResolvedTask> tasks,
-        List<ResolvedTask> errors,
-        List<ResolvedTask> _finally,
-        TaskRun parentTaskRun,
-        RunContext runContext,
-        boolean allowFailure,
-        boolean allowWarning
-    ) {
-        if (ListUtils.emptyOnNull(tasks).stream()
-            .filter(resolvedTask -> !resolvedTask.getTask().getDisabled())
-            .findAny()
-            .isEmpty()) {
-            return Optional.of(State.Type.SUCCESS);
-        }
-
-        return resolveState(
-            execution,
-            tasks,
-            errors,
-            _finally,
-            parentTaskRun,
-            runContext,
-            allowFailure,
-            allowWarning
-        );
-    }
-
     public static Optional<State.Type> resolveState(
         Execution execution,
         List<ResolvedTask> tasks,
@@ -237,7 +207,7 @@ public class FlowableUtils {
             }
         } else {
             // first call, the error flow is not ready, we need to notify the parent task that can be failed to init error flows
-            if (execution.hasFailedNoRetry(tasks, parentTaskRun) || terminalState == State.Type.FAILED) {
+            if (execution.hasFailed(tasks, parentTaskRun) || terminalState == State.Type.FAILED) {
                 return Optional.of(execution.guessFinalState(tasks, parentTaskRun, allowFailure, allowWarning, terminalState));
             }
         }

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

@@ -41,9 +41,6 @@ public class RunContextFactory {
 
     @Inject
     protected VariableRenderer variableRenderer;
-    
-    @Inject
-    protected SecureVariableRendererFactory secureVariableRendererFactory;
 
     @Inject
     protected StorageInterface storageInterface;
@@ -85,33 +82,22 @@ 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(decryptVariables)
-                        .withSecretInputs(secretInputsFromFlow(flow))
+                newRunVariablesBuilder()
+                    .withFlow(flow)
+                    .withExecution(execution)
+                    .withDecryptVariables(true)
+                    .withSecretInputs(secretInputsFromFlow(flow))
                 )
                 .build(runContextLogger, PropertyContext.create(variableRenderer)))
             .withSecretInputs(secretInputsFromFlow(flow))
@@ -123,7 +109,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, this.variableRenderer);
+        return this.of(flow, task, execution, taskRun, decryptVariables, variableRenderer);
     }
 
     public RunContext of(FlowInterface flow, Task task, Execution execution, TaskRun taskRun, boolean decryptVariables, VariableRenderer variableRenderer) {
@@ -161,7 +147,7 @@ public class RunContextFactory {
                 .withFlow(flow)
                 .withTrigger(trigger)
                 .withSecretInputs(secretInputsFromFlow(flow))
-                .build(runContextLogger, PropertyContext.create(this.variableRenderer))
+                .build(runContextLogger, PropertyContext.create(variableRenderer))
             )
             .withSecretInputs(secretInputsFromFlow(flow))
             .withTrigger(trigger)
@@ -240,7 +226,7 @@ public class RunContextFactory {
             // inject mandatory services and config
             .withApplicationContext(applicationContext) // TODO - ideally application should not be injected here
             .withMeterRegistry(metricRegistry)
-            .withVariableRenderer(this.variableRenderer)
+            .withVariableRenderer(variableRenderer)
             .withStorageInterface(storageInterface)
             .withSecretKey(secretKey)
             .withWorkingDir(workingDirFactory.createWorkingDirectory())

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

@@ -10,6 +10,7 @@ import io.kestra.core.models.flows.FlowInterface;
 import io.kestra.core.models.flows.Input;
 import io.kestra.core.models.flows.State;
 import io.kestra.core.models.flows.input.SecretInput;
+import io.kestra.core.models.property.Property;
 import io.kestra.core.models.property.PropertyContext;
 import io.kestra.core.models.tasks.Task;
 import io.kestra.core.models.triggers.AbstractTrigger;
@@ -99,7 +100,7 @@ public final class RunVariables {
      * @return a new immutable {@link Map}.
      */
     static Map<String, Object> of(final AbstractTrigger trigger) {
-        return Map.of(
+        return ImmutableMap.of(
             "id", trigger.getId(),
             "type", trigger.getType()
         );
@@ -281,15 +282,12 @@ public final class RunVariables {
                 }
 
                 if (flow != null && flow.getInputs() != null) {
-                    // Create a new PropertyContext with 'flow' variables which are required by some pebble expressions.
-                    PropertyContextWithVariables context = new PropertyContextWithVariables(propertyContext, Map.of("flow", RunVariables.of(flow)));
-                    
                     // we add default inputs value from the flow if not already set, this will be useful for triggers
                     flow.getInputs().stream()
                         .filter(input -> input.getDefaults() != null && !inputs.containsKey(input.getId()))
                         .forEach(input -> {
                             try {
-                                inputs.put(input.getId(), FlowInputOutput.resolveDefaultValue(input, context));
+                                inputs.put(input.getId(), FlowInputOutput.resolveDefaultValue(input, propertyContext));
                             } catch (IllegalVariableEvaluationException e) {
                                 // Silent catch, if an input depends on another input, or a variable that is populated at runtime / input filling time, we can't resolve it here.
                             }
@@ -393,20 +391,4 @@ public final class RunVariables {
     }
 
     private RunVariables(){}
-    
-    private record PropertyContextWithVariables(
-        PropertyContext delegate,
-        Map<String, Object> variables
-    ) implements PropertyContext {
-        
-        @Override
-        public String render(String inline, Map<String, Object> variables) throws IllegalVariableEvaluationException {
-            return delegate.render(inline, variables.isEmpty() ? this.variables : variables);
-        }
-        
-        @Override
-        public Map<String, Object> render(Map<String, Object> inline, Map<String, Object> variables) throws IllegalVariableEvaluationException {
-            return delegate.render(inline, variables.isEmpty() ? this.variables : variables);
-        }
-    }
 }

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

@@ -3,19 +3,14 @@ package io.kestra.core.runners;
 import com.google.common.annotations.VisibleForTesting;
 import io.kestra.core.models.Label;
 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.FlowInterface;
 import io.kestra.core.queues.QueueException;
 import io.kestra.core.queues.QueueFactoryInterface;
 import io.kestra.core.queues.QueueInterface;
-import io.kestra.core.repositories.ArrayListTotal;
-import io.kestra.core.repositories.ExecutionRepositoryInterface;
 import io.kestra.core.repositories.FlowRepositoryInterface;
 import io.kestra.core.services.ExecutionService;
 import io.kestra.core.utils.Await;
-import io.micronaut.data.model.Pageable;
 import jakarta.inject.Inject;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
@@ -39,16 +34,9 @@ public class RunnerUtils {
     @Named(QueueFactoryInterface.EXECUTION_NAMED)
     protected QueueInterface<Execution> executionQueue;
 
-    @Inject
-    @Named(QueueFactoryInterface.KILL_NAMED)
-    protected QueueInterface<ExecutionKilled> killQueue;
-
     @Inject
     private FlowRepositoryInterface flowRepository;
 
-    @Inject
-    private ExecutionRepositoryInterface executionRepository;
-
     @Inject
     private ExecutionService executionService;
 
@@ -184,62 +172,6 @@ public class RunnerUtils {
         return receive.get();
     }
 
-    public List<Execution> awaitFlowExecutionNumber(int number, String tenantId, String namespace, String flowId) {
-        return awaitFlowExecutionNumber(number, tenantId, namespace, flowId, null);
-    }
-
-    public List<Execution> awaitFlowExecutionNumber(int number, String tenantId, String namespace, String flowId, Duration duration) {
-        AtomicReference<List<Execution>> receive = new AtomicReference<>();
-        Flow flow = flowRepository
-            .findById(tenantId, namespace, flowId, Optional.empty())
-            .orElseThrow(
-                () -> new IllegalArgumentException("Unable to find flow '" + flowId + "'"));
-        try {
-            if (duration == null){
-                duration = Duration.ofSeconds(20);
-            }
-            Await.until(() -> {
-                ArrayListTotal<Execution> byFlowId = executionRepository.findByFlowId(
-                    tenantId, namespace, flowId, Pageable.UNPAGED);
-                if (byFlowId.size() == number
-                    && byFlowId.stream()
-                    .filter(e -> executionService.isTerminated(flow, e))
-                    .toList().size() == number) {
-                    receive.set(byFlowId);
-                    return true;
-                }
-                return false;
-            }, Duration.ofMillis(50), duration);
-
-        } catch (TimeoutException e) {
-            ArrayListTotal<Execution> byFlowId = executionRepository.findByFlowId(
-                tenantId, namespace, flowId, Pageable.UNPAGED);
-            if (!byFlowId.isEmpty()) {
-                throw new RuntimeException("%d Execution found for flow %s, but %d where awaited".formatted(byFlowId.size(), flowId, number));
-            } else {
-                throw new RuntimeException("No execution for flow %s exist in the database".formatted(flowId));
-            }
-        }
-
-        return receive.get();
-    }
-
-    public Execution killExecution(Execution execution) throws QueueException, TimeoutException {
-        killQueue.emit(ExecutionKilledExecution.builder()
-            .executionId(execution.getId())
-            .isOnKillCascade(true)
-            .state(ExecutionKilled.State.REQUESTED)
-            .tenantId(execution.getTenantId())
-            .build());
-
-        return awaitExecution(isTerminatedExecution(
-            execution,
-            flowRepository
-                .findById(execution.getTenantId(), execution.getNamespace(), execution.getFlowId(), Optional.ofNullable(execution.getFlowRevision()))
-                .orElse(null)
-        ), throwRunnable(() -> this.executionQueue.emit(execution)), Duration.ofSeconds(60));
-    }
-
     @VisibleForTesting
     public Execution awaitChildExecution(Flow flow, Execution parentExecution, Runnable executionEmitter, Duration duration) throws TimeoutException {
         return this.awaitExecution(isTerminatedChildExecution(parentExecution, flow), executionEmitter, duration);

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

@@ -1,39 +0,0 @@
-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,44 +2,121 @@ 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 PebbleEngine pebbleEngine;
+    private final PebbleEngine pebbleEngine;
     private final VariableConfiguration variableConfiguration;
 
     @Inject
     public VariableRenderer(ApplicationContext applicationContext, @Nullable VariableConfiguration variableConfiguration) {
-        this(applicationContext.getBean(PebbleEngineFactory.class), variableConfiguration);
+        this(applicationContext, variableConfiguration, Collections.emptyList());
     }
-    
-    public VariableRenderer(PebbleEngineFactory pebbleEngineFactory, @Nullable VariableConfiguration variableConfiguration) {
+
+    public VariableRenderer(ApplicationContext applicationContext, @Nullable VariableConfiguration variableConfiguration, List<String> functionsToMask) {
         this.variableConfiguration = variableConfiguration != null ? variableConfiguration : new VariableConfiguration();
-        this.pebbleEngine = pebbleEngineFactory.create();
+
+        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();
     }
-    
-    public void setPebbleEngine(final PebbleEngine pebbleEngine) {
-        this.pebbleEngine = pebbleEngine;
+
+    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);
+            }
+        );
     }
-    
+
+    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,6 +168,7 @@ 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

@@ -1,118 +0,0 @@
-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/ChunkFilter.java

@@ -1,15 +1,14 @@
 package io.kestra.core.runners.pebble.filters;
 
-import java.util.List;
-import java.util.Map;
-
 import com.google.common.collect.Lists;
-
 import io.pebbletemplates.pebble.error.PebbleException;
 import io.pebbletemplates.pebble.extension.Filter;
 import io.pebbletemplates.pebble.template.EvaluationContext;
 import io.pebbletemplates.pebble.template.PebbleTemplate;
 
+import java.util.List;
+import java.util.Map;
+
 public class ChunkFilter implements Filter {
     @Override
     public List<String> getArgumentNames() {
@@ -31,10 +30,6 @@ public class ChunkFilter implements Filter {
             throw new PebbleException(null, "'chunk' filter can only be applied to List. Actual type was: " + input.getClass().getName(), lineNumber, self.getName());
         }
 
-        Object sizeObj = args.get("size");
-        if (!(sizeObj instanceof Number)) {
-            throw new PebbleException(null, "'chunk' filter argument 'size' must be a number. Actual type was: " + sizeObj.getClass().getName(), lineNumber, self.getName());
-        }
-        return Lists.partition((List) input, ((Number) sizeObj).intValue());
+        return Lists.partition((List) input, ((Long) args.get("size")).intValue());
     }
 }

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

@@ -17,17 +17,12 @@ import java.util.List;
 import java.util.Map;
 
 public class JqFilter implements Filter {
-    // Load Scope once as static to avoid repeated initialization
-    // This improves performance by loading builtin functions only once when the class loads
-    private static final Scope SCOPE;
+    private final Scope scope;
     private final List<String> argumentNames = new ArrayList<>();
 
-    static {
-        SCOPE = Scope.newEmptyScope();
-        BuiltinFunctionLoader.getInstance().loadFunctions(Versions.JQ_1_6, SCOPE);
-    }
-
     public JqFilter() {
+        scope = Scope.newEmptyScope();
+        BuiltinFunctionLoader.getInstance().loadFunctions(Versions.JQ_1_6, scope);
         this.argumentNames.add("expression");
     }
 
@@ -48,7 +43,10 @@ public class JqFilter implements Filter {
 
         String pattern = (String) args.get("expression");
 
+        Scope rootScope = Scope.newEmptyScope();
+        BuiltinFunctionLoader.getInstance().loadFunctions(Versions.JQ_1_6, rootScope);
         try {
+
             JsonQuery q = JsonQuery.compile(pattern, Versions.JQ_1_6);
 
             JsonNode in;
@@ -61,7 +59,7 @@ public class JqFilter implements Filter {
             final List<Object> out = new ArrayList<>();
 
             try {
-                q.apply(Scope.newChildScope(SCOPE), in, v -> {
+                q.apply(scope, in, v -> {
                     if (v instanceof TextNode) {
                         out.add(v.textValue());
                     } else if (v instanceof NullNode) {

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.toNanos(date.toEpochSecond()) + TimeUnit.NANOSECONDS.toMicros(date.getNano()));
+        return String.valueOf(TimeUnit.SECONDS.toMicros(date.toEpochSecond()) + TimeUnit.NANOSECONDS.toMicros(date.getNano()));
     }
 }

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

@@ -151,7 +151,10 @@ abstract class AbstractFileFunction implements Function {
             // if there is a trigger of type execution, we also allow accessing a file from the parent execution
             Map<String, String> trigger = (Map<String, String>) context.getVariable(TRIGGER);
 
-            return isFileUriValid(trigger.get(NAMESPACE), trigger.get("flowId"), trigger.get("executionId"), path);
+            if (!isFileUriValid(trigger.get(NAMESPACE), trigger.get("flowId"), trigger.get("executionId"), path)) {
+                throw new IllegalArgumentException("Unable to read the file '" + path + "' as it didn't belong to the parent execution");
+            }
+            return true;
         }
         return false;
     }

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

@@ -5,6 +5,8 @@ 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;
@@ -101,8 +103,15 @@ 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 (HttpClientException | IllegalVariableEvaluationException | IOException e) {
-            throw new PebbleException(e, "Unable to execute HTTP request", lineNumber, self.getName());
+        } 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());
         }
     }
 

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

@@ -38,7 +38,7 @@ public class KvFunction implements Function {
         String key = getKey(args, self, lineNumber);
         String namespace = (String) args.get(NAMESPACE_ARG);
 
-        boolean errorOnMissing = Optional.ofNullable((Boolean) args.get(ERROR_ON_MISSING_ARG)).orElse(true);
+        Boolean errorOnMissing = Optional.ofNullable((Boolean) args.get(ERROR_ON_MISSING_ARG)).orElse(true);
 
         Map<String, String> flow = (Map<String, String>) context.getVariable("flow");
         String flowNamespace = flow.get(NAMESPACE_ARG);
@@ -53,16 +53,11 @@ public class KvFunction implements Function {
                 // we didn't check allowedNamespace here as it's checked in the kvStoreService itself
                 value = kvStoreService.get(flowTenantId, namespace, flowNamespace).getValue(key);
             }
-        } catch (ResourceExpiredException e) {
-            if (errorOnMissing) {
-                throw new PebbleException(e, e.getMessage(), lineNumber, self.getName());
-            }
-            value = Optional.empty();
         } catch (Exception e) {
             throw new PebbleException(e, e.getMessage(), lineNumber, self.getName());
         }
 
-        if (value.isEmpty() && errorOnMissing) {
+        if (value.isEmpty() && errorOnMissing == Boolean.TRUE) {
             throw new PebbleException(null, "The key '" + key + "' does not exist in the namespace '" + namespace + "'.", lineNumber, self.getName());
         }
 
@@ -90,4 +85,4 @@ public class KvFunction implements Function {
 
         return (String) args.get(KEY_ARGS);
     }
-}
+}

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

@@ -0,0 +1,66 @@
+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,23 +180,13 @@ 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

@@ -14,7 +14,6 @@ import io.kestra.core.models.flows.State;
 import io.kestra.core.models.flows.input.InputAndValue;
 import io.kestra.core.models.hierarchies.AbstractGraphTask;
 import io.kestra.core.models.hierarchies.GraphCluster;
-import io.kestra.core.models.tasks.FlowableTask;
 import io.kestra.core.models.tasks.ResolvedTask;
 import io.kestra.core.models.tasks.Task;
 import io.kestra.core.models.tasks.retrys.AbstractRetry;
@@ -122,38 +121,21 @@ public class ExecutionService {
      * Retry set the given taskRun in created state
      * and return the execution in running state
      **/
-    public Execution retryTask(Execution execution, Flow flow, String taskRunId) throws InternalException {
-        TaskRun taskRun = execution.findTaskRunByTaskRunId(taskRunId).withState(State.Type.CREATED);
-        List<TaskRun> taskRunList = execution.getTaskRunList();
-
-        if (taskRun.getParentTaskRunId() != null) {
-            // we need to find the parent to remove any errors or finally tasks already executed
-            TaskRun parentTaskRun = execution.findTaskRunByTaskRunId(taskRun.getParentTaskRunId());
-            Task parentTask = flow.findTaskByTaskId(parentTaskRun.getTaskId());
-            if (parentTask instanceof FlowableTask<?> flowableTask) {
-                if (flowableTask.getErrors() != null) {
-                    List<Task> allErrors = Stream.concat(flowableTask.getErrors().stream()
-                                .filter(task -> task.isFlowable() && ((FlowableTask<?>) task).getErrors() != null)
-                                .flatMap(task -> ((FlowableTask<?>) task).getErrors().stream()),
-                            flowableTask.getErrors().stream())
-                        .toList();
-                    allErrors.forEach(error -> taskRunList.removeIf(t -> t.getTaskId().equals(error.getId())));
+    public Execution retryTask(Execution execution, String taskRunId) {
+        List<TaskRun> newTaskRuns = execution
+            .getTaskRunList()
+            .stream()
+            .map(taskRun -> {
+                if (taskRun.getId().equals(taskRunId)) {
+                    return taskRun
+                        .withState(State.Type.CREATED);
                 }
 
-                if (flowableTask.getFinally() != null) {
-                    List<Task> allFinally = Stream.concat(flowableTask.getFinally().stream()
-                                .filter(task -> task.isFlowable() && ((FlowableTask<?>) task).getFinally() != null)
-                                .flatMap(task -> ((FlowableTask<?>) task).getFinally().stream()),
-                            flowableTask.getFinally().stream())
-                        .toList();
-                    allFinally.forEach(error -> taskRunList.removeIf(t -> t.getTaskId().equals(error.getId())));
-                }
-            }
+                return taskRun;
+            })
+            .toList();
 
-            return execution.withTaskRunList(taskRunList).withTaskRun(taskRun).withState(State.Type.RUNNING);
-        }
-
-        return execution.withTaskRun(taskRun).withState(State.Type.RUNNING);
+        return execution.withTaskRunList(newTaskRuns).withState(State.Type.RUNNING);
     }
 
     public Execution retryWaitFor(Execution execution, String flowableTaskRunId) {
@@ -383,7 +365,6 @@ public class ExecutionService {
             if (!isFlowable || s.equals(taskRunId)) {
                 TaskRun newTaskRun;
 
-                State.Type targetState = newState;
                 if (task instanceof Pause pauseTask) {
                     State.Type terminalState = newState == State.Type.RUNNING ? State.Type.SUCCESS : newState;
                     Pause.Resumed _resumed = resumed != null ? resumed : Pause.Resumed.now(terminalState);
@@ -393,23 +374,23 @@ public class ExecutionService {
                     // if it's a Pause task with no subtask, we terminate the task
                     if (ListUtils.isEmpty(pauseTask.getTasks()) && ListUtils.isEmpty(pauseTask.getErrors()) && ListUtils.isEmpty(pauseTask.getFinally())) {
                         if (newState == State.Type.RUNNING) {
-                            targetState = State.Type.SUCCESS;
+                            newTaskRun = newTaskRun.withState(State.Type.SUCCESS);
                         } else if (newState == State.Type.KILLING) {
-                            targetState = State.Type.KILLED;
+                            newTaskRun = newTaskRun.withState(State.Type.KILLED);
+                        } else {
+                            newTaskRun = newTaskRun.withState(newState);
                         }
                     } else {
                         // we should set the state to RUNNING so that subtasks are executed
-                        targetState = State.Type.RUNNING;
+                        newTaskRun = newTaskRun.withState(State.Type.RUNNING);
                     }
-                    newTaskRun =  newTaskRun.withState(targetState);
                 } else {
-                    newTaskRun = originalTaskRun.withState(targetState);
+                    newTaskRun =  originalTaskRun.withState(newState);
                 }
 
-
                 if (originalTaskRun.getAttempts() != null && !originalTaskRun.getAttempts().isEmpty()) {
                     ArrayList<TaskRunAttempt> attempts = new ArrayList<>(originalTaskRun.getAttempts());
-                    attempts.set(attempts.size() - 1, attempts.getLast().withState(targetState));
+                    attempts.set(attempts.size() - 1, attempts.getLast().withState(newState));
                     newTaskRun = newTaskRun.withAttempts(attempts);
                 }
 
@@ -728,7 +709,7 @@ public class ExecutionService {
             // An edge case can exist where the execution is resumed automatically before we resume it with a killing.
             try {
                 newExecution = this.resume(execution, flow, State.Type.KILLING, null);
-                newExecution = newExecution.withState(killingOrAfterKillState);
+                newExecution = newExecution.withState(afterKillState.orElse(newExecution.getState().getCurrent()));
             } catch (Exception e) {
                 // if we cannot resume, we set it anyway to killing, so we don't throw
                 log.warn("Unable to resume a paused execution before killing it", e);
@@ -737,12 +718,11 @@ public class ExecutionService {
         } else {
             newExecution = execution.withState(killingOrAfterKillState);
         }
-        
-        // Because this method is expected to be called by the Executor we can return the Execution 
+
+        // 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) {
         return this.kill(execution, flow, Optional.empty());
     }

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

@@ -5,11 +5,14 @@ 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();
@@ -22,11 +25,11 @@ public class SkipExecutionService {
     }
 
     public synchronized void setSkipFlows(List<String> skipFlows) {
-        this.skipFlows = skipFlows == null ? Collections.emptyList() : skipFlows.stream().map(FlowId::from).toList();
+        this.skipFlows = skipFlows == null ? Collections.emptyList() : skipFlows.stream().map(FlowId::from).filter(Objects::nonNull).toList();
     }
 
     public synchronized void setSkipNamespaces(List<String> skipNamespaces) {
-        this.skipNamespaces = skipNamespaces == null ? Collections.emptyList() : skipNamespaces.stream().map(NamespaceId::from).toList();
+        this.skipNamespaces = skipNamespaces == null ? Collections.emptyList() : skipNamespaces.stream().map(NamespaceId::from).filter(Objects::nonNull).toList();
     }
 
     public synchronized void setSkipTenants(List<String> skipTenants) {
@@ -73,19 +76,31 @@ public class SkipExecutionService {
     }
 
     record FlowId(String tenant, String namespace, String flow) {
-        static FlowId from(String flowId) {
+        static @Nullable 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 new FlowId(null, parts[0], parts[1]);
+
+            return null;
         }
     };
 
     record NamespaceId(String tenant, String namespace) {
-        static NamespaceId from(String namespaceId) {
+        static @Nullable NamespaceId from(String namespaceId) {
             String[] parts = SkipExecutionService.splitIdParts(namespaceId);
-            return new NamespaceId(parts[0], parts[1]);
+
+            if (parts.length == 2) {
+                return new NamespaceId(parts[0], parts[1]);
+            } else {
+                log.error("Invalid namespace skip with values:'{}'", namespaceId);
+            }
+
+            return null;
         }
     };
 }

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

@@ -1,5 +0,0 @@
-package io.kestra.core.utils;
-
-public class RegexPatterns {
-    public static final String JAVA_IDENTIFIER_REGEX = "^[A-Za-z_$][A-Za-z0-9_$]*(\\.[A-Za-z_$][A-Za-z0-9_$]*)*$";
-}

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

@@ -46,16 +46,19 @@ public class VersionProvider {
         this.date = loadTime(gitProperties);
         this.version = loadVersion(buildProperties, gitProperties);
 
-        // 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()
-                );
-            }
+        // 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()
+            );
         }
     }
 

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

@@ -33,13 +33,11 @@ public class ExecutionsDataFilterValidator implements ConstraintValidator<Execut
             }
         });
 
-        if (executionsDataFilter.getWhere() != null) {
-            executionsDataFilter.getWhere().forEach(filter -> {
-                if (filter.getField() == Executions.Fields.LABELS && filter.getLabelKey() == null) {
-                    violations.add("Label filters must have a `labelKey`.");
-                }
-            });
-        }
+        executionsDataFilter.getWhere().forEach(filter -> {
+            if (filter.getField() == Executions.Fields.LABELS && filter.getLabelKey() == null) {
+                violations.add("Label filters must have a `labelKey`.");
+            }
+        });
 
         if (!violations.isEmpty()) {
             context.disableDefaultConstraintViolation();

core/src/main/java/io/kestra/plugin/core/dashboard/chart/mardown/sources/MarkdownSource.java

@@ -7,8 +7,6 @@ import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
 import lombok.Getter;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 @Getter
 @JsonTypeInfo(
     use = JsonTypeInfo.Id.NAME,
@@ -22,6 +20,6 @@ import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
 public class MarkdownSource {
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp = "\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     private String type;
 }

core/src/main/java/io/kestra/plugin/core/dashboard/data/Flows.java

@@ -0,0 +1,52 @@
+package io.kestra.plugin.core.dashboard.data;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonTypeName;
+import io.kestra.core.models.annotations.Example;
+import io.kestra.core.models.annotations.Plugin;
+import io.kestra.core.models.dashboards.ColumnDescriptor;
+import io.kestra.core.models.dashboards.DataFilter;
+import io.kestra.core.repositories.FlowRepositoryInterface;
+import io.kestra.core.repositories.QueryBuilderInterface;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+@SuperBuilder(toBuilder = true)
+@Getter
+@NoArgsConstructor
+@JsonInclude(JsonInclude.Include.NON_DEFAULT)
+@EqualsAndHashCode
+@Schema(
+    title = "Display Flow data in a dashboard chart."
+)
+@Plugin(
+    examples = {
+        @Example(
+            title = "Display a chart with a list of Flows.",
+            full = true,
+            code = { """
+            charts:
+              - id: list_flows
+                type: io.kestra.plugin.core.dashboard.chart.Table
+                data:
+                  type: io.kestra.plugin.core.dashboard.data.Flows
+                  columns:
+                    namespace:
+                      field: NAMESPACE
+                    id:
+                      field: ID
+            """
+          }
+        )
+    }
+)
+@JsonTypeName("Flows")
+public class Flows<C extends ColumnDescriptor<Flows.Fields>> extends DataFilter<Flows.Fields, C> implements IFlows {
+    @Override
+    public Class<? extends QueryBuilderInterface<Fields>> repositoryClass() {
+        return FlowRepositoryInterface.class;
+    }
+}